typed-serverless/lib/aws/types.d.ts

Helps you write a consistent Serverless Framework configuration in TypeScript

import { AWS } from '@serverless/typescript';
import { CfnResourceProps, ICfnResource } from 'typed-aws';
export declare type BaseResourceParams = {
    name: string;
};
export declare type ResourceType = 'resource' | 'function';
export declare type ResourceProps = CfnResourceProps;
export declare type Resource<T extends CfnResourceProps> = ICfnResource<T>;
export declare type ResourceBuilder<TResourceBuilderParams, T extends CfnResourceProps = CfnResourceProps> = (resource: TResourceBuilderParams) => Resource<T>;
export declare type Resources<TResourceId extends string, TResource extends Resource<TResourceProps>, TResourceProps extends CfnResourceProps = CfnResourceProps> = {
    [key in TResourceId]?: ResourceAdapter<TResource, TResourceProps>;
};
export declare type ServerlessAWSResource = Exclude<AWSResources, undefined>[string];
export declare type ResourceAdapter<T, X extends CfnResourceProps> = T extends Resource<X> ? ServerlessAWSResource : T;
export declare type FunctionBuilder<TFunctionBuilderParams> = (resource: TFunctionBuilderParams) => ServerlessAWSFunction;
export declare type Functions<TFunctionId extends string> = {
    [key in TFunctionId]?: ServerlessAWSFunction;
};
declare type ServerlessAWSFunction = Exclude<AWS['functions'], undefined>[string];
export declare type ServerlessFunction = ServerlessAWSFunction;
declare type AWSResources = Exclude<Exclude<AWS['resources'], undefined>['Resources'], undefined>;
export declare type FnSub = {
    'Fn::Sub': string;
} | {
    'Fn::Sub': [string, Record<string, unknown>];
};
export declare type ProcessContext<T> = {
    config: T;
    resourceNames: Record<string, string>;
    resourceTypes: Record<string, ResourceType>;
    errors: string[];
};
export declare type HookPhase = 'before-resource' | 'after-resource' | 'before-reference' | 'after-reference' | 'before-stringify' | 'after-stringify';
export declare type HookProcessor<TConfigType> = (context: ProcessContext<TConfigType>) => void;
export declare type Hooks<TConfigType> = {
    [key in HookPhase]?: HookProcessor<TConfigType>;
};
export declare type TypedServerlessParams<TId extends string = string, TResourceParams extends BaseResourceParams = BaseResourceParams, TConfigType extends AWS = AWS> = {
    resourceParamsFactory: (id: TId, config: TConfigType) => TResourceParams;
    onResourceCreated?: (resource: Resource<CfnResourceProps>) => void;
    onFunctionCreated?: (lambda: ServerlessFunction) => void;
    hooks?: Hooks<TConfigType>;
};
export declare type PlaceholderProcessor<ConfigType> = (processContext: ProcessContext<ConfigType>) => void;
export {};