@altt/altt/lib/types.d.ts

/// <reference types="node" />
import * as ts from 'typescript';
import { EventEmitter } from 'events';
export interface Hooks {
    precompile?: string;
    postcompile?: string;
    preinstall?: string;
    postinstall?: string;
    prezip?: string;
    postzip?: string;
    predeploy?: string;
    postdeploy?: string;
    prebuild?: string;
    postbuild?: string;
}
export interface FunctionOptions {
    projectName: string;
    name: string;
    description: string;
    memory?: number;
    timeout?: number;
    role?: string;
    runtime?: string;
    environment: {
        [index: string]: string;
    };
    handler: string;
    buildDir: string;
    installCmd?: string;
    hooks?: Hooks;
    deploy?: {
        using: string;
    };
}
export interface TemplateContext {
    [index: string]: any;
}
export interface CompileResultSuccess {
    diagnostics: ts.Diagnostic[];
    externals: ts.ResolvedModuleFull[];
    success: true;
}
export interface CompileResultFailure {
    diagnostics: ts.Diagnostic[];
    success: false;
}
export declare type CompileResult = CompileResultSuccess | CompileResultFailure;
export interface AlttEnvironment {
}
export declare type AnyPromise = Promise<any>;
export declare type TaskFunction = (input?: any) => AnyPromise;
export interface Task extends EventEmitter {
    name: string;
    error: boolean;
    done: boolean;
    running: boolean;
    run(): Promise<void>;
}
export declare type Deployer = (environment: AlttEnvironment, argv: string[]) => Promise<void>;
export interface AlttFunction {
    alttOptions: FunctionOptions;
    name: string;
    env: AlttEnvironment;
    root: string;
    dir: string;
    buildDir: string;
    entry: string;
    tsOptions: ts.CompilerOptions;
    zipPath: string;
    prepare(): Promise<void>;
    compile(): Promise<CompileResult>;
    installDependencies(): Promise<void>;
    zip(): Promise<void>;
}
export interface LambdaClientContext {
    client: {
        installation_id: string;
        app_title: string;
        app_version_name: string;
        app_version_code: string;
        app_package_name: string;
    };
    Custom: any;
    env: {
        platform_version: string;
        platform: string;
        make: string;
        model: string;
        locale: string;
    };
}
export interface LambdaContext {
    getRemainingTimeInMillis(): number;
    callbackWaitsForEmptyEventLoop: boolean;
    functionName: string;
    functionVersion: string;
    invokedFunctionArn: string;
    memoryLimitInMB: number;
    awsRequestId: string;
    logGroupName: string;
    logStreamName: string;
    identity: string | null;
    clientContext: LambdaClientContext | null;
}
export declare type LambdaCallback<T> = (error: any, result: T) => void;