@aligent/cdk-prerender-proxy 0.2.5-experimental5 → 0.2.6

package/lib/handlers/node_modules/@types/aws-lambda/trigger/api-gateway-proxy.d.ts

@@ -0,0 +1,187 @@
+import {
+    APIGatewayEventDefaultAuthorizerContext,
+    APIGatewayEventRequestContextWithAuthorizer,
+} from "../common/api-gateway";
+import { Callback, Handler } from "../handler";
+
+/**
+ * Works with Lambda Proxy Integration for Rest API or HTTP API integration Payload Format version 1.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+export type APIGatewayProxyHandler = Handler<APIGatewayProxyEvent, APIGatewayProxyResult>;
+/**
+ * Works with Lambda Proxy Integration for Rest API or HTTP API integration Payload Format version 1.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+export type APIGatewayProxyCallback = Callback<APIGatewayProxyResult>;
+
+/**
+ * Works with HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+export type APIGatewayProxyHandlerV2<T = never> = Handler<APIGatewayProxyEventV2, APIGatewayProxyResultV2<T>>;
+/**
+ * Works with HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+export type APIGatewayProxyCallbackV2 = Callback<APIGatewayProxyResultV2>;
+
+/**
+ * Works with Lambda Proxy Integration for Rest API or HTTP API integration Payload Format version 1.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+export type APIGatewayProxyEvent = APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>;
+
+export type APIGatewayProxyWithLambdaAuthorizerHandler<TAuthorizerContext> =
+    Handler<APIGatewayProxyWithLambdaAuthorizerEvent<TAuthorizerContext>, APIGatewayProxyResult>;
+
+export type APIGatewayProxyWithCognitoAuthorizerHandler =
+    Handler<APIGatewayProxyWithCognitoAuthorizerEvent, APIGatewayProxyResult>;
+
+export type APIGatewayProxyWithLambdaAuthorizerEvent<TAuthorizerContext> =
+    APIGatewayProxyEventBase<APIGatewayEventLambdaAuthorizerContext<TAuthorizerContext>>;
+
+export type APIGatewayProxyWithLambdaAuthorizerEventRequestContext<TAuthorizerContext> =
+    APIGatewayEventRequestContextWithAuthorizer<APIGatewayEventLambdaAuthorizerContext<TAuthorizerContext>>;
+
+// API Gateway proxy integration mangles the context from a custom authorizer,
+// converting all number or boolean properties to string, and adding some extra properties.
+export type APIGatewayEventLambdaAuthorizerContext<TAuthorizerContext> = {
+    [P in keyof TAuthorizerContext]: TAuthorizerContext[P] extends null ? null : string;
+} & {
+    principalId: string;
+    integrationLatency: number;
+};
+
+export type APIGatewayProxyWithCognitoAuthorizerEvent = APIGatewayProxyEventBase<APIGatewayProxyCognitoAuthorizer>;
+
+// All claims are coerced into strings.
+export interface APIGatewayProxyCognitoAuthorizer {
+    claims: {
+        [name: string]: string;
+    };
+}
+
+export interface APIGatewayProxyEventHeaders {
+    [name: string]: string | undefined;
+}
+
+export interface APIGatewayProxyEventMultiValueHeaders {
+    [name: string]: string[] | undefined;
+}
+
+export interface APIGatewayProxyEventPathParameters {
+    [name: string]: string | undefined;
+}
+
+export interface APIGatewayProxyEventQueryStringParameters {
+    [name: string]: string | undefined;
+}
+
+export interface APIGatewayProxyEventMultiValueQueryStringParameters {
+    [name: string]: string[] | undefined;
+}
+
+export interface APIGatewayProxyEventStageVariables {
+    [name: string]: string | undefined;
+}
+
+export interface APIGatewayProxyEventBase<TAuthorizerContext> {
+    body: string | null;
+    headers: APIGatewayProxyEventHeaders;
+    multiValueHeaders: APIGatewayProxyEventMultiValueHeaders;
+    httpMethod: string;
+    isBase64Encoded: boolean;
+    path: string;
+    pathParameters: APIGatewayProxyEventPathParameters | null;
+    queryStringParameters: APIGatewayProxyEventQueryStringParameters | null;
+    multiValueQueryStringParameters: APIGatewayProxyEventMultiValueQueryStringParameters | null;
+    stageVariables: APIGatewayProxyEventStageVariables | null;
+    requestContext: APIGatewayEventRequestContextWithAuthorizer<TAuthorizerContext>;
+    resource: string;
+}
+
+/**
+ * Works with Lambda Proxy Integration for Rest API or HTTP API integration Payload Format version 1.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+export interface APIGatewayProxyResult {
+    statusCode: number;
+    headers?: {
+        [header: string]: boolean | number | string;
+    };
+    multiValueHeaders?: {
+        [header: string]: Array<boolean | number | string>;
+    };
+    body: string;
+    isBase64Encoded?: boolean;
+}
+
+/**
+ * Works with HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+export interface APIGatewayProxyEventV2 {
+    version: string;
+    routeKey: string;
+    rawPath: string;
+    rawQueryString: string;
+    cookies?: string[];
+    headers: APIGatewayProxyEventHeaders;
+    queryStringParameters?: APIGatewayProxyEventQueryStringParameters;
+    requestContext: {
+        accountId: string;
+        apiId: string;
+        authorizer?: {
+            jwt: {
+                claims: { [name: string]: string | number | boolean | string[] };
+                scopes: string[];
+            };
+        };
+        domainName: string;
+        domainPrefix: string;
+        http: {
+            method: string;
+            path: string;
+            protocol: string;
+            sourceIp: string;
+            userAgent: string;
+        };
+        requestId: string;
+        routeKey: string;
+        stage: string;
+        time: string;
+        timeEpoch: number;
+    };
+    body?: string;
+    pathParameters?: APIGatewayProxyEventPathParameters;
+    isBase64Encoded: boolean;
+    stageVariables?: APIGatewayProxyEventStageVariables;
+}
+
+/**
+ * Works with HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+export type APIGatewayProxyResultV2<T = never> = APIGatewayProxyStructuredResultV2 | string | T;
+
+/**
+ * Interface for structured response with `statusCode` and`headers`
+ * Works with HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+export interface APIGatewayProxyStructuredResultV2 {
+    statusCode?: number;
+    headers?: {
+        [header: string]: boolean | number | string;
+    };
+    body?: string;
+    isBase64Encoded?: boolean;
+    cookies?: string[];
+}
+
+// Legacy names
+export type ProxyHandler = APIGatewayProxyHandler;
+export type ProxyCallback = APIGatewayProxyCallback;
+export type APIGatewayEvent = APIGatewayProxyEvent;
+export type ProxyResult = APIGatewayProxyResult;

package/lib/handlers/node_modules/@types/aws-lambda/trigger/appsync-resolver.d.ts

@@ -0,0 +1,51 @@
+import { Handler } from '../handler';
+
+export type AppSyncResolverHandler<T, V> = Handler<AppSyncResolverEvent<T>, V | V[]>;
+
+export interface AppSyncResolverEventHeaders {
+    [name: string]: string | undefined;
+}
+
+/**
+ * See https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference.html
+ *
+ * @param T type of the arguments
+ */
+export interface AppSyncResolverEvent<T> {
+    arguments: T;
+    identity?: AppSyncIdentityIAM | AppSyncIdentityCognito;
+    source: { [key: string]: any } | null;
+    request: {
+        headers: AppSyncResolverEventHeaders;
+    };
+    info: {
+        selectionSetList: string[];
+        selectionSetGraphQL: string;
+        parentTypeName: string;
+        fieldName: string;
+        variables: { [key: string]: any };
+    };
+    prev: { result: { [key: string]: any } } | null;
+    stash: { [key: string]: any };
+}
+
+export interface AppSyncIdentityIAM {
+    accountId: string;
+    cognitoIdentityPoolId: string;
+    cognitoIdentityId: string;
+    sourceIp: string[];
+    username: string;
+    userArn: string;
+    cognitoIdentityAuthType: string;
+    cognitoIdentityAuthProvider: string;
+}
+
+export interface AppSyncIdentityCognito {
+    sub: string;
+    issuer: string;
+    username: string;
+    claims: any;
+    sourceIp: string[];
+    defaultAuthStrategy: string;
+    groups: string[] | null;
+}

package/lib/handlers/node_modules/@types/aws-lambda/trigger/cloudformation-custom-resource.d.ts

@@ -0,0 +1,68 @@
+import { Handler } from "../handler";
+
+// Note, responses are *not* lambda results, they are sent to the event ResponseURL.
+export type CloudFormationCustomResourceHandler = Handler<CloudFormationCustomResourceEvent, void>;
+
+export type CloudFormationCustomResourceEvent =
+    | CloudFormationCustomResourceCreateEvent
+    | CloudFormationCustomResourceUpdateEvent
+    | CloudFormationCustomResourceDeleteEvent;
+
+export type CloudFormationCustomResourceResponse =
+    | CloudFormationCustomResourceSuccessResponse
+    | CloudFormationCustomResourceFailedResponse;
+
+/**
+ * CloudFormation Custom Resource event and response
+ * http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/crpg-ref.html
+ */
+export interface CloudFormationCustomResourceEventCommon {
+    ServiceToken: string;
+    ResponseURL: string;
+    StackId: string;
+    RequestId: string;
+    LogicalResourceId: string;
+    ResourceType: string;
+    ResourceProperties: {
+        ServiceToken: string;
+        [Key: string]: any;
+    };
+}
+
+export interface CloudFormationCustomResourceCreateEvent extends CloudFormationCustomResourceEventCommon {
+    RequestType: 'Create';
+}
+
+export interface CloudFormationCustomResourceUpdateEvent extends CloudFormationCustomResourceEventCommon {
+    RequestType: 'Update';
+    PhysicalResourceId: string;
+    OldResourceProperties: {
+        [Key: string]: any;
+    };
+}
+
+export interface CloudFormationCustomResourceDeleteEvent extends CloudFormationCustomResourceEventCommon {
+    RequestType: 'Delete';
+    PhysicalResourceId: string;
+}
+
+export interface CloudFormationCustomResourceResponseCommon {
+    PhysicalResourceId: string;
+    StackId: string;
+    RequestId: string;
+    LogicalResourceId: string;
+    Data?: {
+        [Key: string]: any;
+    };
+    NoEcho?: boolean;
+}
+
+export interface CloudFormationCustomResourceSuccessResponse extends CloudFormationCustomResourceResponseCommon {
+    Status: 'SUCCESS';
+    Reason?: string;
+}
+
+export interface CloudFormationCustomResourceFailedResponse extends CloudFormationCustomResourceResponseCommon {
+    Status: 'FAILED';
+    Reason: string;
+}

package/lib/handlers/node_modules/@types/aws-lambda/trigger/cloudfront-request.d.ts

@@ -0,0 +1,20 @@
+import { CloudFrontEvent, CloudFrontRequest, CloudFrontResultResponse } from "../common/cloudfront";
+import { Handler, Callback } from "../handler";
+
+export type CloudFrontRequestHandler = Handler<CloudFrontRequestEvent, CloudFrontRequestResult>;
+export type CloudFrontRequestCallback = Callback<CloudFrontRequestResult>;
+
+/**
+ * CloudFront viewer request or origin request event
+ *
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html#lambda-event-structure-request
+ */
+export interface CloudFrontRequestEvent {
+    Records: Array<{
+        cf: CloudFrontEvent & {
+            request: CloudFrontRequest;
+        };
+    }>;
+}
+
+export type CloudFrontRequestResult = undefined | null | CloudFrontResultResponse | CloudFrontRequest;

package/lib/handlers/node_modules/@types/aws-lambda/trigger/cloudfront-response.d.ts

@@ -0,0 +1,21 @@
+import { CloudFrontEvent, CloudFrontRequest, CloudFrontResponse, CloudFrontResultResponse } from "../common/cloudfront";
+import { Callback, Handler } from "../handler";
+
+export type CloudFrontResponseHandler = Handler<CloudFrontResponseEvent, CloudFrontResponseResult>;
+export type CloudFrontResponseCallback = Callback<CloudFrontResponseResult>;
+
+/**
+ * CloudFront viewer response or origin response event
+ *
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html#lambda-event-structure-response
+ */
+export interface CloudFrontResponseEvent {
+    Records: Array<{
+        cf: CloudFrontEvent & {
+            readonly request: Pick<CloudFrontRequest, Exclude<keyof CloudFrontRequest, 'body'>>;
+            response: CloudFrontResponse;
+        };
+    }>;
+}
+
+export type CloudFrontResponseResult = undefined | null | CloudFrontResultResponse;

package/lib/handlers/node_modules/@types/aws-lambda/trigger/cloudwatch-events.d.ts

@@ -0,0 +1,8 @@
+import { EventBridgeHandler, EventBridgeEvent } from '../trigger/eventbridge';
+
+export type ScheduledHandler<TDetail = any> = EventBridgeHandler<'Scheduled Event', TDetail, void>;
+
+/**
+ * https://docs.aws.amazon.com/lambda/latest/dg/with-scheduled-events.html
+ */
+export interface ScheduledEvent<TDetail = any> extends EventBridgeEvent<'Scheduled Event', TDetail> {}

package/lib/handlers/node_modules/@types/aws-lambda/trigger/cloudwatch-logs.d.ts

@@ -0,0 +1,37 @@
+import { Handler } from "../handler";
+
+export type CloudWatchLogsHandler = Handler<CloudWatchLogsEvent, void>;
+
+/**
+ * See http://docs.aws.amazon.com/lambda/latest/dg/eventsources.html#eventsources-cloudwatch-logs
+ */
+export interface CloudWatchLogsEvent {
+    awslogs: CloudWatchLogsEventData;
+}
+
+export interface CloudWatchLogsEventData {
+    data: string;
+}
+
+export interface CloudWatchLogsDecodedData {
+    owner: string;
+    logGroup: string;
+    logStream: string;
+    subscriptionFilters: string[];
+    messageType: string;
+    logEvents: CloudWatchLogsLogEvent[];
+}
+
+export interface CloudWatchLogsLogEventExtractedFields {
+    [name: string]: string | undefined;
+}
+
+/**
+ * See http://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SubscriptionFilters.html#LambdaFunctionExample
+ */
+export interface CloudWatchLogsLogEvent {
+    id: string;
+    timestamp: number;
+    message: string;
+    extractedFields?: CloudWatchLogsLogEventExtractedFields;
+}

package/lib/handlers/node_modules/@types/aws-lambda/trigger/codebuild-cloudwatch-state.d.ts

@@ -0,0 +1,104 @@
+import { EventBridgeEvent, EventBridgeHandler } from './eventbridge';
+
+export type CodeBuildCloudWatchStateHandler = EventBridgeHandler<'CodeBuild Build State Change', CodeBuildStateEventDetail, void>;
+
+export type CodeBuildStateType = 'IN_PROGRESS' | 'SUCCEEDED' | 'FAILED' | 'STOPPED';
+export type CodeBuildPhaseType =
+    | 'COMPLETED'
+    | 'FINALIZING'
+    | 'UPLOAD_ARTIFACTS'
+    | 'POST_BUILD'
+    | 'BUILD'
+    | 'PRE_BUILD'
+    | 'INSTALL'
+    | 'QUEUED'
+    | 'DOWNLOAD_SOURCE'
+    | 'PROVISIONING'
+    | 'SUBMITTED';
+export type CodeBuildPhaseStatusType =
+    | 'TIMED_OUT'
+    | 'STOPPED'
+    | 'FAILED'
+    | 'SUCCEEDED'
+    | 'FAULT'
+    | 'CLIENT_ERROR';
+export type CodeBuildCacheType = 'NO_CACHE' | 'LOCAL' | 'S3';
+export type CodeBuildSourceLocationType =
+    | 'CODECOMMIT'
+    | 'CODEPIPELINE'
+    | 'GITHUB'
+    | 'GITHUB_ENTERPRISE'
+    | 'BITBUCKET'
+    | 'S3'
+    | 'NO_SOURCE';
+export type CodeBuildEnvironmentType =
+    | 'LINUX_CONTAINER'
+    | 'LINUX_GPU_CONTAINER'
+    | 'WINDOWS_CONTAINER'
+    | 'ARM_CONTAINER';
+export type CodeBuildEnvironmentPullCredentialsType = 'CODEBUILD' | 'SERVICE_ROLE';
+export type CodeBuildEnvironmentComputeType =
+    | 'BUILD_GENERAL1_SMALL'
+    | 'BUILD_GENERAL1_MEDIUM'
+    | 'BUILD_GENERAL1_LARGE'
+    | 'BUILD_GENERAL1_2XLARGE';
+export type CodeBuildEnvironmentVariableType = 'PARAMETER_STORE' | 'PLAINTEXT' | 'SECRETS_MANAGER';
+
+export interface CodeBuildStateEventDetail {
+    'build-status': CodeBuildStateType;
+    'project-name': string;
+    'build-id': string;
+    'current-phase': CodeBuildPhaseType;
+    'current-phase-context': string;
+    version: string;
+    'additional-information': {
+        cache: {
+            type: CodeBuildCacheType;
+        };
+        'build-number': number;
+        'timeout-in-minutes': number;
+        'build-complete': boolean;
+        initiator: string;
+        'build-start-time': string;
+        source: {
+            buildspec: string;
+            location: string;
+            type: CodeBuildSourceLocationType;
+        };
+        'source-version': string;
+        artifact: {
+            location: string;
+        };
+        environment: {
+            image: string;
+            'privileged-mode': boolean;
+            'image-pull-credentials-type'?: CodeBuildEnvironmentPullCredentialsType;
+            'compute-type': CodeBuildEnvironmentComputeType;
+            type: CodeBuildEnvironmentType;
+            'environment-variables': Array<{
+                name: string;
+                type?: CodeBuildEnvironmentVariableType;
+                value: string;
+            }>;
+        };
+        'project-file-system-locations': [];
+        logs: {
+            'group-name': string;
+            'stream-name': string;
+            'deep-link': string;
+        };
+        phases: Array<{
+            'phase-context'?: string[]; // Not available for COMPLETED phase-type
+            'start-time': string;
+            'end-time'?: string; // Not available for COMPLETED phase-type
+            'duration-in-seconds'?: number; // Not available for COMPLETED phase-type
+            'phase-type': CodeBuildPhaseType;
+            'phase-status'?: CodeBuildPhaseStatusType; // Not available for COMPLETED phase-type
+        }>;
+        'queued-timeout-in-minutes': number;
+    };
+}
+
+export interface CodeBuildCloudWatchStateEvent extends EventBridgeEvent<'CodeBuild Build State Change', CodeBuildStateEventDetail> {
+    source: 'aws.codebuild';
+}

package/lib/handlers/node_modules/@types/aws-lambda/trigger/codepipeline-cloudwatch-action.d.ts

@@ -0,0 +1,31 @@
+import { Handler } from "../handler";
+
+export type CodePipelineCloudWatchActionHandler = Handler<CodePipelineCloudWatchActionEvent, void>;
+
+export type CodePipelineActionCategory = 'Approval' | 'Build' | 'Deploy' | 'Invoke' | 'Source' | 'Test';
+export type CodePipelineActionState = 'STARTED' | 'SUCCEEDED' | 'FAILED' | 'CANCELED';
+
+export interface CodePipelineCloudWatchActionEvent {
+    version: string;
+    id: string;
+    'detail-type': 'CodePipeline Action Execution State Change';
+    source: 'aws.codepipeline';
+    account: string;
+    time: string;
+    region: string;
+    resources: string[];
+    detail: {
+        pipeline: string;
+        version: number;
+        'execution-id': string;
+        stage: string;
+        action: string;
+        state: CodePipelineActionState;
+        type: {
+            owner: 'AWS' | 'Custom' | 'ThirdParty';
+            category: CodePipelineActionCategory;
+            provider: string;
+            version: number;
+        };
+    };
+}

package/lib/handlers/node_modules/@types/aws-lambda/trigger/codepipeline-cloudwatch-pipeline.d.ts

@@ -0,0 +1,32 @@
+import { Handler } from "../handler";
+
+export type CodePipelineCloudWatchPipelineHandler = Handler<CodePipelineCloudWatchPipelineEvent, void>;
+
+export type CodePipelineState = 'STARTED' | 'SUCCEEDED' | 'RESUMED' | 'FAILED' | 'CANCELED' | 'SUPERSEDED';
+
+/**
+ * CodePipeline CloudWatch Events
+ * https://docs.aws.amazon.com/codepipeline/latest/userguide/detect-state-changes-cloudwatch-events.html
+ *
+ * The above CodePipelineEvent is when a lambda is invoked by a CodePipeline.
+ * These events are when you subscribe to CodePipeline events in CloudWatch.
+ *
+ * Their documentation says that detail.version is a string, but it is actually an integer
+ */
+
+export interface CodePipelineCloudWatchPipelineEvent {
+    version: string;
+    id: string;
+    'detail-type': 'CodePipeline Pipeline Execution State Change';
+    source: 'aws.codepipeline';
+    account: string;
+    time: string;
+    region: string;
+    resources: string[];
+    detail: {
+        pipeline: string;
+        version: number;
+        state: CodePipelineState;
+        'execution-id': string;
+    };
+}

package/lib/handlers/node_modules/@types/aws-lambda/trigger/codepipeline-cloudwatch-stage.d.ts

@@ -0,0 +1,23 @@
+import { Handler } from "../handler";
+
+export type CodePipelineCloudWatchStageHandler = Handler<CodePipelineCloudWatchStageEvent, void>;
+
+export type CodePipelineStageState = 'STARTED' | 'SUCCEEDED' | 'RESUMED' | 'FAILED' | 'CANCELED';
+
+export interface CodePipelineCloudWatchStageEvent {
+    version: string;
+    id: string;
+    'detail-type': 'CodePipeline Stage Execution State Change';
+    source: 'aws.codepipeline';
+    account: string;
+    time: string;
+    region: string;
+    resources: string[];
+    detail: {
+        pipeline: string;
+        version: number;
+        'execution-id': string;
+        stage: string;
+        state: CodePipelineStageState;
+    };
+}

package/lib/handlers/node_modules/@types/aws-lambda/trigger/codepipeline-cloudwatch.d.ts

@@ -0,0 +1,11 @@
+import { Handler } from "../handler";
+import { CodePipelineCloudWatchActionEvent } from "./codepipeline-cloudwatch-action";
+import { CodePipelineCloudWatchPipelineEvent } from "./codepipeline-cloudwatch-pipeline";
+import { CodePipelineCloudWatchStageEvent } from "./codepipeline-cloudwatch-stage";
+
+export type CodePipelineCloudWatchHandler = Handler<CodePipelineCloudWatchEvent, void>;
+
+export type CodePipelineCloudWatchEvent =
+    | CodePipelineCloudWatchPipelineEvent
+    | CodePipelineCloudWatchStageEvent
+    | CodePipelineCloudWatchActionEvent;

package/lib/handlers/node_modules/@types/aws-lambda/trigger/codepipeline.d.ts

@@ -0,0 +1,55 @@
+import { Handler } from "../handler";
+
+export type CodePipelineHandler = Handler<CodePipelineEvent, void>;
+
+/**
+ * CodePipeline events
+ * https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-invoke-lambda-function.html
+ */
+export interface S3ArtifactLocation {
+    bucketName: string;
+    objectKey: string;
+}
+export interface S3ArtifactStore {
+    type: 'S3';
+    s3Location: S3ArtifactLocation;
+}
+
+export type ArtifactLocation = S3ArtifactStore;
+
+export interface Artifact {
+    name: string;
+    revision: string | null;
+    location: ArtifactLocation;
+}
+
+export interface Credentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+}
+
+export interface EncryptionKey {
+    type: string;
+    id: string;
+}
+
+export interface CodePipelineEvent {
+    'CodePipeline.job': {
+        id: string;
+        accountId: string;
+        data: {
+            actionConfiguration: {
+                configuration: {
+                    FunctionName: string;
+                    UserParameters: string;
+                };
+            };
+            inputArtifacts: Artifact[];
+            outputArtifacts: Artifact[];
+            artifactCredentials: Credentials;
+            encryptionKey?: EncryptionKey & { type: 'KMS' };
+            continuationToken?: string;
+        };
+    };
+}