@types/aws-lambda

  • Version 8.10.81
  • Published
  • 103 kB
  • No dependencies
  • MIT license

Install

npm i @types/aws-lambda
yarn add @types/aws-lambda
pnpm add @types/aws-lambda

Overview

TypeScript definitions for AWS Lambda

Index

Interfaces

Type Aliases

Interfaces

interface ALBEvent

interface ALBEvent {}

    property body

    body: string | null;

      property headers

      headers?: ALBEventHeaders | undefined;

        property httpMethod

        httpMethod: string;

          property isBase64Encoded

          isBase64Encoded: boolean;

            property multiValueHeaders

            multiValueHeaders?: ALBEventMultiValueHeaders | undefined;

              property multiValueQueryStringParameters

              multiValueQueryStringParameters?:
              | ALBEventMultiValueQueryStringParameters
              | undefined;

                property path

                path: string;

                  property queryStringParameters

                  queryStringParameters?: ALBEventQueryStringParameters | undefined;

                    property requestContext

                    requestContext: ALBEventRequestContext;

                      interface ALBEventHeaders

                      interface ALBEventHeaders {}

                        index signature

                        [name: string]: string | undefined;

                          interface ALBEventMultiValueHeaders

                          interface ALBEventMultiValueHeaders {}

                            index signature

                            [name: string]: string[] | undefined;

                              interface ALBEventMultiValueQueryStringParameters

                              interface ALBEventMultiValueQueryStringParameters {}

                                index signature

                                [name: string]: string[] | undefined;

                                  interface ALBEventQueryStringParameters

                                  interface ALBEventQueryStringParameters {}

                                    index signature

                                    [name: string]: string | undefined;

                                      interface ALBEventRequestContext

                                      interface ALBEventRequestContext {}

                                        property elb

                                        elb: {
                                        targetGroupArn: string;
                                        };

                                          interface ALBResult

                                          interface ALBResult {}

                                            property body

                                            body?: string | undefined;

                                              property headers

                                              headers?: { [header: string]: boolean | number | string } | undefined;

                                                property isBase64Encoded

                                                isBase64Encoded?: boolean | undefined;

                                                  property multiValueHeaders

                                                  multiValueHeaders?:
                                                  | { [header: string]: Array<boolean | number | string> }
                                                  | undefined;

                                                    property statusCode

                                                    statusCode: number;

                                                      property statusDescription

                                                      statusDescription?: string | undefined;

                                                        interface APIGatewayAuthorizerResult

                                                        interface APIGatewayAuthorizerResult {}

                                                          property context

                                                          context?: APIGatewayAuthorizerResultContext | null | undefined;

                                                            property policyDocument

                                                            policyDocument: PolicyDocument;

                                                              property principalId

                                                              principalId: string;

                                                                property usageIdentifierKey

                                                                usageIdentifierKey?: string | null | undefined;

                                                                  interface APIGatewayAuthorizerResultContext

                                                                  interface APIGatewayAuthorizerResultContext {}

                                                                    index signature

                                                                    [name: string]: string | number | boolean | null | undefined;

                                                                      interface APIGatewayAuthorizerWithContextResult

                                                                      interface APIGatewayAuthorizerWithContextResult<
                                                                      TAuthorizerContext extends APIGatewayAuthorizerResultContext
                                                                      > {}

                                                                        property context

                                                                        context: TAuthorizerContext;

                                                                          property policyDocument

                                                                          policyDocument: PolicyDocument;

                                                                            property principalId

                                                                            principalId: string;

                                                                              property usageIdentifierKey

                                                                              usageIdentifierKey?: string | null | undefined;

                                                                                interface APIGatewayEventClientCertificate

                                                                                interface APIGatewayEventClientCertificate {}

                                                                                  property clientCertPem

                                                                                  clientCertPem: string;

                                                                                    property issuerDN

                                                                                    issuerDN: string;

                                                                                      property serialNumber

                                                                                      serialNumber: string;

                                                                                        property subjectDN

                                                                                        subjectDN: string;

                                                                                          property validity

                                                                                          validity: {
                                                                                          notAfter: string;
                                                                                          notBefore: string;
                                                                                          };

                                                                                            interface APIGatewayEventIdentity

                                                                                            interface APIGatewayEventIdentity {}

                                                                                              property accessKey

                                                                                              accessKey: string | null;

                                                                                                property accountId

                                                                                                accountId: string | null;

                                                                                                  property apiKey

                                                                                                  apiKey: string | null;

                                                                                                    property apiKeyId

                                                                                                    apiKeyId: string | null;

                                                                                                      property caller

                                                                                                      caller: string | null;

                                                                                                        property clientCert

                                                                                                        clientCert: APIGatewayEventClientCertificate | null;

                                                                                                          property cognitoAuthenticationProvider

                                                                                                          cognitoAuthenticationProvider: string | null;

                                                                                                            property cognitoAuthenticationType

                                                                                                            cognitoAuthenticationType: string | null;

                                                                                                              property cognitoIdentityId

                                                                                                              cognitoIdentityId: string | null;

                                                                                                                property cognitoIdentityPoolId

                                                                                                                cognitoIdentityPoolId: string | null;

                                                                                                                  property principalOrgId

                                                                                                                  principalOrgId: string | null;

                                                                                                                    property sourceIp

                                                                                                                    sourceIp: string;

                                                                                                                      property user

                                                                                                                      user: string | null;

                                                                                                                        property userAgent

                                                                                                                        userAgent: string | null;

                                                                                                                          property userArn

                                                                                                                          userArn: string | null;

                                                                                                                            interface APIGatewayEventRequestContextWithAuthorizer

                                                                                                                            interface APIGatewayEventRequestContextWithAuthorizer<TAuthorizerContext> {}

                                                                                                                              property accountId

                                                                                                                              accountId: string;

                                                                                                                                property apiId

                                                                                                                                apiId: string;

                                                                                                                                  property authorizer

                                                                                                                                  authorizer: TAuthorizerContext;

                                                                                                                                    property connectedAt

                                                                                                                                    connectedAt?: number | undefined;

                                                                                                                                      property connectionId

                                                                                                                                      connectionId?: string | undefined;

                                                                                                                                        property domainName

                                                                                                                                        domainName?: string | undefined;

                                                                                                                                          property domainPrefix

                                                                                                                                          domainPrefix?: string | undefined;

                                                                                                                                            property eventType

                                                                                                                                            eventType?: string | undefined;

                                                                                                                                              property extendedRequestId

                                                                                                                                              extendedRequestId?: string | undefined;

                                                                                                                                                property httpMethod

                                                                                                                                                httpMethod: string;

                                                                                                                                                  property identity

                                                                                                                                                  identity: APIGatewayEventIdentity;

                                                                                                                                                    property messageDirection

                                                                                                                                                    messageDirection?: string | undefined;

                                                                                                                                                      property messageId

                                                                                                                                                      messageId?: string | null | undefined;

                                                                                                                                                        property path

                                                                                                                                                        path: string;

                                                                                                                                                          property protocol

                                                                                                                                                          protocol: string;

                                                                                                                                                            property requestId

                                                                                                                                                            requestId: string;

                                                                                                                                                              property requestTime

                                                                                                                                                              requestTime?: string | undefined;

                                                                                                                                                                property requestTimeEpoch

                                                                                                                                                                requestTimeEpoch: number;

                                                                                                                                                                  property resourceId

                                                                                                                                                                  resourceId: string;

                                                                                                                                                                    property resourcePath

                                                                                                                                                                    resourcePath: string;

                                                                                                                                                                      property routeKey

                                                                                                                                                                      routeKey?: string | undefined;

                                                                                                                                                                        property stage

                                                                                                                                                                        stage: string;

                                                                                                                                                                          interface APIGatewayProxyCognitoAuthorizer

                                                                                                                                                                          interface APIGatewayProxyCognitoAuthorizer {}

                                                                                                                                                                            property claims

                                                                                                                                                                            claims: {
                                                                                                                                                                            [name: string]: string;
                                                                                                                                                                            };

                                                                                                                                                                              interface APIGatewayProxyEventBase

                                                                                                                                                                              interface APIGatewayProxyEventBase<TAuthorizerContext> {}

                                                                                                                                                                                property body

                                                                                                                                                                                body: string | null;

                                                                                                                                                                                  property headers

                                                                                                                                                                                  headers: APIGatewayProxyEventHeaders;

                                                                                                                                                                                    property httpMethod

                                                                                                                                                                                    httpMethod: string;

                                                                                                                                                                                      property isBase64Encoded

                                                                                                                                                                                      isBase64Encoded: boolean;

                                                                                                                                                                                        property multiValueHeaders

                                                                                                                                                                                        multiValueHeaders: APIGatewayProxyEventMultiValueHeaders;

                                                                                                                                                                                          property multiValueQueryStringParameters

                                                                                                                                                                                          multiValueQueryStringParameters: APIGatewayProxyEventMultiValueQueryStringParameters | null;

                                                                                                                                                                                            property path

                                                                                                                                                                                            path: string;

                                                                                                                                                                                              property pathParameters

                                                                                                                                                                                              pathParameters: APIGatewayProxyEventPathParameters | null;

                                                                                                                                                                                                property queryStringParameters

                                                                                                                                                                                                queryStringParameters: APIGatewayProxyEventQueryStringParameters | null;

                                                                                                                                                                                                  property requestContext

                                                                                                                                                                                                  requestContext: APIGatewayEventRequestContextWithAuthorizer<TAuthorizerContext>;

                                                                                                                                                                                                    property resource

                                                                                                                                                                                                    resource: string;

                                                                                                                                                                                                      property stageVariables

                                                                                                                                                                                                      stageVariables: APIGatewayProxyEventStageVariables | null;

                                                                                                                                                                                                        interface APIGatewayProxyEventHeaders

                                                                                                                                                                                                        interface APIGatewayProxyEventHeaders {}

                                                                                                                                                                                                          index signature

                                                                                                                                                                                                          [name: string]: string | undefined;

                                                                                                                                                                                                            interface APIGatewayProxyEventMultiValueHeaders

                                                                                                                                                                                                            interface APIGatewayProxyEventMultiValueHeaders {}

                                                                                                                                                                                                              index signature

                                                                                                                                                                                                              [name: string]: string[] | undefined;

                                                                                                                                                                                                                interface APIGatewayProxyEventMultiValueQueryStringParameters

                                                                                                                                                                                                                interface APIGatewayProxyEventMultiValueQueryStringParameters {}

                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                  [name: string]: string[] | undefined;

                                                                                                                                                                                                                    interface APIGatewayProxyEventPathParameters

                                                                                                                                                                                                                    interface APIGatewayProxyEventPathParameters {}

                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                      [name: string]: string | undefined;

                                                                                                                                                                                                                        interface APIGatewayProxyEventQueryStringParameters

                                                                                                                                                                                                                        interface APIGatewayProxyEventQueryStringParameters {}

                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                          [name: string]: string | undefined;

                                                                                                                                                                                                                            interface APIGatewayProxyEventStageVariables

                                                                                                                                                                                                                            interface APIGatewayProxyEventStageVariables {}

                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                              [name: string]: string | undefined;

                                                                                                                                                                                                                                interface APIGatewayProxyEventV2

                                                                                                                                                                                                                                interface APIGatewayProxyEventV2 {}
                                                                                                                                                                                                                                • Works with HTTP API integration Payload Format version 2.0

                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                  • - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html

                                                                                                                                                                                                                                property body

                                                                                                                                                                                                                                body?: string | undefined;

                                                                                                                                                                                                                                  property cookies

                                                                                                                                                                                                                                  cookies?: string[] | undefined;

                                                                                                                                                                                                                                    property headers

                                                                                                                                                                                                                                    headers: APIGatewayProxyEventHeaders;

                                                                                                                                                                                                                                      property isBase64Encoded

                                                                                                                                                                                                                                      isBase64Encoded: boolean;

                                                                                                                                                                                                                                        property pathParameters

                                                                                                                                                                                                                                        pathParameters?: APIGatewayProxyEventPathParameters | undefined;

                                                                                                                                                                                                                                          property queryStringParameters

                                                                                                                                                                                                                                          queryStringParameters?: APIGatewayProxyEventQueryStringParameters | undefined;

                                                                                                                                                                                                                                            property rawPath

                                                                                                                                                                                                                                            rawPath: string;

                                                                                                                                                                                                                                              property rawQueryString

                                                                                                                                                                                                                                              rawQueryString: string;

                                                                                                                                                                                                                                                property requestContext

                                                                                                                                                                                                                                                requestContext: {
                                                                                                                                                                                                                                                accountId: string;
                                                                                                                                                                                                                                                apiId: string;
                                                                                                                                                                                                                                                authorizer?:
                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                jwt: {
                                                                                                                                                                                                                                                claims: {
                                                                                                                                                                                                                                                [name: string]: string | number | boolean | string[];
                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                scopes: string[];
                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                | undefined;
                                                                                                                                                                                                                                                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;
                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                  property routeKey

                                                                                                                                                                                                                                                  routeKey: string;

                                                                                                                                                                                                                                                    property stageVariables

                                                                                                                                                                                                                                                    stageVariables?: APIGatewayProxyEventStageVariables | undefined;

                                                                                                                                                                                                                                                      property version

                                                                                                                                                                                                                                                      version: string;

                                                                                                                                                                                                                                                        interface APIGatewayProxyResult

                                                                                                                                                                                                                                                        interface APIGatewayProxyResult {}
                                                                                                                                                                                                                                                        • Works with Lambda Proxy Integration for Rest API or HTTP API integration Payload Format version 1.0

                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                          • - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html

                                                                                                                                                                                                                                                        property body

                                                                                                                                                                                                                                                        body: string;

                                                                                                                                                                                                                                                          property headers

                                                                                                                                                                                                                                                          headers?:
                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                          [header: string]: boolean | number | string;
                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                            property isBase64Encoded

                                                                                                                                                                                                                                                            isBase64Encoded?: boolean | undefined;

                                                                                                                                                                                                                                                              property multiValueHeaders

                                                                                                                                                                                                                                                              multiValueHeaders?:
                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                              [header: string]: Array<boolean | number | string>;
                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                property statusCode

                                                                                                                                                                                                                                                                statusCode: number;

                                                                                                                                                                                                                                                                  interface APIGatewayProxyStructuredResultV2

                                                                                                                                                                                                                                                                  interface APIGatewayProxyStructuredResultV2 {}
                                                                                                                                                                                                                                                                  • Interface for structured response with statusCode andheaders Works with HTTP API integration Payload Format version 2.0

                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                    • - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html

                                                                                                                                                                                                                                                                  property body

                                                                                                                                                                                                                                                                  body?: string | undefined;

                                                                                                                                                                                                                                                                    property cookies

                                                                                                                                                                                                                                                                    cookies?: string[] | undefined;

                                                                                                                                                                                                                                                                      property headers

                                                                                                                                                                                                                                                                      headers?:
                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                      [header: string]: boolean | number | string;
                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                        property isBase64Encoded

                                                                                                                                                                                                                                                                        isBase64Encoded?: boolean | undefined;

                                                                                                                                                                                                                                                                          property statusCode

                                                                                                                                                                                                                                                                          statusCode?: number | undefined;

                                                                                                                                                                                                                                                                            interface APIGatewayRequestAuthorizerEvent

                                                                                                                                                                                                                                                                            interface APIGatewayRequestAuthorizerEvent {}

                                                                                                                                                                                                                                                                              property headers

                                                                                                                                                                                                                                                                              headers: APIGatewayRequestAuthorizerEventHeaders | null;

                                                                                                                                                                                                                                                                                property httpMethod

                                                                                                                                                                                                                                                                                httpMethod: string;

                                                                                                                                                                                                                                                                                  property methodArn

                                                                                                                                                                                                                                                                                  methodArn: string;

                                                                                                                                                                                                                                                                                    property multiValueHeaders

                                                                                                                                                                                                                                                                                    multiValueHeaders: APIGatewayRequestAuthorizerEventMultiValueHeaders | null;

                                                                                                                                                                                                                                                                                      property multiValueQueryStringParameters

                                                                                                                                                                                                                                                                                      multiValueQueryStringParameters: APIGatewayRequestAuthorizerEventMultiValueQueryStringParameters | null;

                                                                                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                                                                                        path: string;

                                                                                                                                                                                                                                                                                          property pathParameters

                                                                                                                                                                                                                                                                                          pathParameters: APIGatewayRequestAuthorizerEventPathParameters | null;

                                                                                                                                                                                                                                                                                            property queryStringParameters

                                                                                                                                                                                                                                                                                            queryStringParameters: APIGatewayRequestAuthorizerEventQueryStringParameters | null;

                                                                                                                                                                                                                                                                                              property requestContext

                                                                                                                                                                                                                                                                                              requestContext: APIGatewayEventRequestContextWithAuthorizer<undefined>;

                                                                                                                                                                                                                                                                                                property resource

                                                                                                                                                                                                                                                                                                resource: string;

                                                                                                                                                                                                                                                                                                  property stageVariables

                                                                                                                                                                                                                                                                                                  stageVariables: APIGatewayRequestAuthorizerEventStageVariables | null;

                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                    type: 'REQUEST';

                                                                                                                                                                                                                                                                                                      interface APIGatewayRequestAuthorizerEventHeaders

                                                                                                                                                                                                                                                                                                      interface APIGatewayRequestAuthorizerEventHeaders {}

                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                        [name: string]: string | undefined;

                                                                                                                                                                                                                                                                                                          interface APIGatewayRequestAuthorizerEventMultiValueHeaders

                                                                                                                                                                                                                                                                                                          interface APIGatewayRequestAuthorizerEventMultiValueHeaders {}

                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                            [name: string]: string[] | undefined;

                                                                                                                                                                                                                                                                                                              interface APIGatewayRequestAuthorizerEventMultiValueQueryStringParameters

                                                                                                                                                                                                                                                                                                              interface APIGatewayRequestAuthorizerEventMultiValueQueryStringParameters {}

                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                [name: string]: string[] | undefined;

                                                                                                                                                                                                                                                                                                                  interface APIGatewayRequestAuthorizerEventPathParameters

                                                                                                                                                                                                                                                                                                                  interface APIGatewayRequestAuthorizerEventPathParameters {}

                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                    [name: string]: string | undefined;

                                                                                                                                                                                                                                                                                                                      interface APIGatewayRequestAuthorizerEventQueryStringParameters

                                                                                                                                                                                                                                                                                                                      interface APIGatewayRequestAuthorizerEventQueryStringParameters {}

                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                        [name: string]: string | undefined;

                                                                                                                                                                                                                                                                                                                          interface APIGatewayRequestAuthorizerEventStageVariables

                                                                                                                                                                                                                                                                                                                          interface APIGatewayRequestAuthorizerEventStageVariables {}

                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                            [name: string]: string | undefined;

                                                                                                                                                                                                                                                                                                                              interface APIGatewayTokenAuthorizerEvent

                                                                                                                                                                                                                                                                                                                              interface APIGatewayTokenAuthorizerEvent {}

                                                                                                                                                                                                                                                                                                                                property authorizationToken

                                                                                                                                                                                                                                                                                                                                authorizationToken: string;

                                                                                                                                                                                                                                                                                                                                  property methodArn

                                                                                                                                                                                                                                                                                                                                  methodArn: string;

                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                    type: 'TOKEN';

                                                                                                                                                                                                                                                                                                                                      interface AppSyncIdentityCognito

                                                                                                                                                                                                                                                                                                                                      interface AppSyncIdentityCognito {}

                                                                                                                                                                                                                                                                                                                                        property claims

                                                                                                                                                                                                                                                                                                                                        claims: any;

                                                                                                                                                                                                                                                                                                                                          property defaultAuthStrategy

                                                                                                                                                                                                                                                                                                                                          defaultAuthStrategy: string;

                                                                                                                                                                                                                                                                                                                                            property groups

                                                                                                                                                                                                                                                                                                                                            groups: string[] | null;

                                                                                                                                                                                                                                                                                                                                              property issuer

                                                                                                                                                                                                                                                                                                                                              issuer: string;

                                                                                                                                                                                                                                                                                                                                                property sourceIp

                                                                                                                                                                                                                                                                                                                                                sourceIp: string[];

                                                                                                                                                                                                                                                                                                                                                  property sub

                                                                                                                                                                                                                                                                                                                                                  sub: string;

                                                                                                                                                                                                                                                                                                                                                    property username

                                                                                                                                                                                                                                                                                                                                                    username: string;

                                                                                                                                                                                                                                                                                                                                                      interface AppSyncIdentityIAM

                                                                                                                                                                                                                                                                                                                                                      interface AppSyncIdentityIAM {}

                                                                                                                                                                                                                                                                                                                                                        property accountId

                                                                                                                                                                                                                                                                                                                                                        accountId: string;

                                                                                                                                                                                                                                                                                                                                                          property cognitoIdentityAuthProvider

                                                                                                                                                                                                                                                                                                                                                          cognitoIdentityAuthProvider: string;

                                                                                                                                                                                                                                                                                                                                                            property cognitoIdentityAuthType

                                                                                                                                                                                                                                                                                                                                                            cognitoIdentityAuthType: string;

                                                                                                                                                                                                                                                                                                                                                              property cognitoIdentityId

                                                                                                                                                                                                                                                                                                                                                              cognitoIdentityId: string;

                                                                                                                                                                                                                                                                                                                                                                property cognitoIdentityPoolId

                                                                                                                                                                                                                                                                                                                                                                cognitoIdentityPoolId: string;

                                                                                                                                                                                                                                                                                                                                                                  property sourceIp

                                                                                                                                                                                                                                                                                                                                                                  sourceIp: string[];

                                                                                                                                                                                                                                                                                                                                                                    property userArn

                                                                                                                                                                                                                                                                                                                                                                    userArn: string;

                                                                                                                                                                                                                                                                                                                                                                      property username

                                                                                                                                                                                                                                                                                                                                                                      username: string;

                                                                                                                                                                                                                                                                                                                                                                        interface AppSyncResolverEvent

                                                                                                                                                                                                                                                                                                                                                                        interface AppSyncResolverEvent<TArguments, TSource = Record<string, any> | null> {}
                                                                                                                                                                                                                                                                                                                                                                        • See https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference.html

                                                                                                                                                                                                                                                                                                                                                                          Parameter TArguments

                                                                                                                                                                                                                                                                                                                                                                          type of the arguments

                                                                                                                                                                                                                                                                                                                                                                          Parameter TSource

                                                                                                                                                                                                                                                                                                                                                                          type of the source

                                                                                                                                                                                                                                                                                                                                                                        property arguments

                                                                                                                                                                                                                                                                                                                                                                        arguments: TArguments;

                                                                                                                                                                                                                                                                                                                                                                          property identity

                                                                                                                                                                                                                                                                                                                                                                          identity?: AppSyncIdentityIAM | AppSyncIdentityCognito | undefined;

                                                                                                                                                                                                                                                                                                                                                                            property info

                                                                                                                                                                                                                                                                                                                                                                            info: {
                                                                                                                                                                                                                                                                                                                                                                            selectionSetList: string[];
                                                                                                                                                                                                                                                                                                                                                                            selectionSetGraphQL: string;
                                                                                                                                                                                                                                                                                                                                                                            parentTypeName: string;
                                                                                                                                                                                                                                                                                                                                                                            fieldName: string;
                                                                                                                                                                                                                                                                                                                                                                            variables: { [key: string]: any };
                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                              property prev

                                                                                                                                                                                                                                                                                                                                                                              prev: { result: { [key: string]: any } } | null;

                                                                                                                                                                                                                                                                                                                                                                                property request

                                                                                                                                                                                                                                                                                                                                                                                request: {
                                                                                                                                                                                                                                                                                                                                                                                headers: AppSyncResolverEventHeaders;
                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                                                  source: TSource;

                                                                                                                                                                                                                                                                                                                                                                                    property stash

                                                                                                                                                                                                                                                                                                                                                                                    stash: { [key: string]: any };

                                                                                                                                                                                                                                                                                                                                                                                      interface AppSyncResolverEventHeaders

                                                                                                                                                                                                                                                                                                                                                                                      interface AppSyncResolverEventHeaders {}

                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                        [name: string]: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                          interface Artifact

                                                                                                                                                                                                                                                                                                                                                                                          interface Artifact {}

                                                                                                                                                                                                                                                                                                                                                                                            property location

                                                                                                                                                                                                                                                                                                                                                                                            location: ArtifactLocation;

                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                                                                                                property revision

                                                                                                                                                                                                                                                                                                                                                                                                revision: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                  interface AttributeValue

                                                                                                                                                                                                                                                                                                                                                                                                  interface AttributeValue {}

                                                                                                                                                                                                                                                                                                                                                                                                    property B

                                                                                                                                                                                                                                                                                                                                                                                                    B?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                      property BOOL

                                                                                                                                                                                                                                                                                                                                                                                                      BOOL?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                        property BS

                                                                                                                                                                                                                                                                                                                                                                                                        BS?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                          property L

                                                                                                                                                                                                                                                                                                                                                                                                          L?: AttributeValue[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                            property M

                                                                                                                                                                                                                                                                                                                                                                                                            M?: { [id: string]: AttributeValue } | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                              property N

                                                                                                                                                                                                                                                                                                                                                                                                              N?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                property NS

                                                                                                                                                                                                                                                                                                                                                                                                                NS?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                  property NULL

                                                                                                                                                                                                                                                                                                                                                                                                                  NULL?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                    property S

                                                                                                                                                                                                                                                                                                                                                                                                                    S?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                      property SS

                                                                                                                                                                                                                                                                                                                                                                                                                      SS?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                        interface BaseCustomEmailSenderTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                        interface BaseCustomEmailSenderTriggerEvent<T extends string>
                                                                                                                                                                                                                                                                                                                                                                                                                        extends BaseTriggerEvent<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                          property request

                                                                                                                                                                                                                                                                                                                                                                                                                          request: {
                                                                                                                                                                                                                                                                                                                                                                                                                          type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          code: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                          userAttributes: StringMap;
                                                                                                                                                                                                                                                                                                                                                                                                                          clientMetadata?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                            interface BaseCustomMessageTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                            interface BaseCustomMessageTriggerEvent<T extends string>
                                                                                                                                                                                                                                                                                                                                                                                                                            extends BaseTriggerEvent<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                              property request

                                                                                                                                                                                                                                                                                                                                                                                                                              request: {
                                                                                                                                                                                                                                                                                                                                                                                                                              userAttributes: StringMap;
                                                                                                                                                                                                                                                                                                                                                                                                                              codeParameter: string;
                                                                                                                                                                                                                                                                                                                                                                                                                              usernameParameter: string;
                                                                                                                                                                                                                                                                                                                                                                                                                              clientMetadata?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                property response

                                                                                                                                                                                                                                                                                                                                                                                                                                response: {
                                                                                                                                                                                                                                                                                                                                                                                                                                smsMessage: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                emailMessage: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                emailSubject: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BasePostConfirmationTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BasePostConfirmationTriggerEvent<T extends string>
                                                                                                                                                                                                                                                                                                                                                                                                                                  extends BaseTriggerEvent<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property request

                                                                                                                                                                                                                                                                                                                                                                                                                                    request: {
                                                                                                                                                                                                                                                                                                                                                                                                                                    userAttributes: StringMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                    clientMetadata?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface BasePreSignUpTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface BasePreSignUpTriggerEvent<T extends string> extends BaseTriggerEvent<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        property request

                                                                                                                                                                                                                                                                                                                                                                                                                                        request: {
                                                                                                                                                                                                                                                                                                                                                                                                                                        userAttributes: StringMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                        validationData?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                        clientMetadata?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                          property response

                                                                                                                                                                                                                                                                                                                                                                                                                                          response: {
                                                                                                                                                                                                                                                                                                                                                                                                                                          autoConfirmUser: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                          autoVerifyEmail: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                          autoVerifyPhone: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface BasePreTokenGenerationTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface BasePreTokenGenerationTriggerEvent<T extends string>
                                                                                                                                                                                                                                                                                                                                                                                                                                            extends BaseTriggerEvent<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              property request

                                                                                                                                                                                                                                                                                                                                                                                                                                              request: {
                                                                                                                                                                                                                                                                                                                                                                                                                                              userAttributes: StringMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                              groupConfiguration: GroupOverrideDetails;
                                                                                                                                                                                                                                                                                                                                                                                                                                              clientMetadata?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                property response

                                                                                                                                                                                                                                                                                                                                                                                                                                                response: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                claimsOverrideDetails: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                claimsToAddOrOverride?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                claimsToSuppress?: string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                groupOverrideDetails?: GroupOverrideDetails | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BaseStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BaseStatement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Condition

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Condition?: ConditionBlock | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Effect

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Effect: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Sid

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sid?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface BaseUserMigrationTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface BaseUserMigrationTriggerEvent<T extends string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                          extends BaseTriggerEvent<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property request

                                                                                                                                                                                                                                                                                                                                                                                                                                                            request: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            password: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            validationData?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            clientMetadata?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property response

                                                                                                                                                                                                                                                                                                                                                                                                                                                              response: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              userAttributes: StringMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              finalUserStatus?: UserStatus | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              messageAction?: 'RESEND' | 'SUPPRESS' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              desiredDeliveryMediums: Array<'SMS' | 'EMAIL'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              forceAliasCreation?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ClientContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ClientContext {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  client: ClientContextClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Custom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      env: ClientContextEnv;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ClientContextClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ClientContextClient {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property appPackageName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          appPackageName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property appTitle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            appTitle: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property appVersionCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              appVersionCode: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property appVersionName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                appVersionName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property installationId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  installationId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ClientContextEnv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ClientContextEnv {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property locale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      locale: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property make

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        make: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property model

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          model: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property platform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            platform: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property platformVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              platformVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CloudFormationCustomResourceCreateEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CloudFormationCustomResourceCreateEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extends CloudFormationCustomResourceEventCommon {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property RequestType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RequestType: 'Create';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CloudFormationCustomResourceDeleteEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CloudFormationCustomResourceDeleteEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extends CloudFormationCustomResourceEventCommon {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property PhysicalResourceId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PhysicalResourceId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property RequestType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RequestType: 'Delete';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CloudFormationCustomResourceEventCommon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CloudFormationCustomResourceEventCommon {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • CloudFormation Custom Resource event and response http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/crpg-ref.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property LogicalResourceId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          LogicalResourceId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property RequestId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            RequestId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ResourceProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ResourceProperties: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ServiceToken: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [Key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ResourceType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ResourceType: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ResponseURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ResponseURL: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ServiceToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ServiceToken: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property StackId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      StackId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CloudFormationCustomResourceFailedResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CloudFormationCustomResourceFailedResponse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extends CloudFormationCustomResourceResponseCommon {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Reason

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Reason: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Status: 'FAILED';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CloudFormationCustomResourceResponseCommon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CloudFormationCustomResourceResponseCommon {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Data?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [Key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property LogicalResourceId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  LogicalResourceId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property NoEcho

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NoEcho?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property PhysicalResourceId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PhysicalResourceId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property RequestId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RequestId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property StackId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          StackId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CloudFormationCustomResourceSuccessResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CloudFormationCustomResourceSuccessResponse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extends CloudFormationCustomResourceResponseCommon {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Reason

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Reason?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Status: 'SUCCESS';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloudFormationCustomResourceUpdateEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloudFormationCustomResourceUpdateEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  extends CloudFormationCustomResourceEventCommon {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property OldResourceProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OldResourceProperties: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [Key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property PhysicalResourceId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PhysicalResourceId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property RequestType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RequestType: 'Update';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CloudFrontCustomOrigin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CloudFrontCustomOrigin {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property customHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            customHeaders: CloudFrontHeaders;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property domainName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              domainName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property keepaliveTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                keepaliveTimeout: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    port: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property protocol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protocol: 'http' | 'https';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property readTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readTimeout: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property sslProtocols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sslProtocols: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CloudFrontEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CloudFrontEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              config: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly distributionDomainName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly distributionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly eventType:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'origin-request'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'origin-response'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'viewer-request'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'viewer-response';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly requestId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CloudFrontFunctionsCookies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CloudFrontFunctionsCookies {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-event-structure.html#functions-event-structure-query-header-cookie

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                attributes?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                multiValue?: Array<{ value: string; attributes?: string }>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloudFrontFunctionsEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloudFrontFunctionsEvent {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-event-structure.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      export const handler = async (event: CloudFrontFunctionsEvent) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var response = event.response;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var headers = response.headers;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // Set the cache-control header
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      headers["cache-control"] = { value: "public,max-age=31536000,immutable" };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // Return response to viewers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      return response
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  context: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** The CloudFront domain name (for example, d111111abcdef8.cloudfront.net) of the distribution that’s associated with the event. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  distributionDomainName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** The ID of the distribution (for example, EDFDVBD6EXAMPLE) that’s associated with the event. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  distributionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** The event type, either `viewer-request` or `viewer-response`. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  eventType: 'viewer-request' | 'viewer-response';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** A string that uniquely identifies a CloudFront request (and its associated response). */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  requestId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ## Context object The context object contains contextual information about the event. It includes the following fields: - distributionDomainName - distributionId - eventType - requestId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  request: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** The HTTP method of the request. If your function code returns a `request`, it cannot modify this field. This is the only read-only field in the `request` object. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * The relative path of the requested object. If your function modifies the `uri value, note the following:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * - The new `uri` value must begin with a forward slash (`/`)`.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * - When a function changes the `uri` value, it changes the object that the viewer is requesting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * - When a function changes the `uri` value, it doesn’t change the cache behavior for the request or the origin that an origin request is sent to.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  uri: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * An object that represents the query string in the request. If the request doesn’t include a query string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * the `request` object still includes an empty `querystring` object.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * The `querystring` object contains one field for each query string parameter in the request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Query string parameter names are converted to lowercase.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  querystring: CloudFrontFunctionsQuerystring;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * An object that represents the HTTP headers in the request. If the request contains any `Cookie` headers,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * those headers are not part of the `headers` object. Cookies are represented separately in the `cookies` object.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * The `headers` object contains one field for each header in the request. Header names are converted to lowercase.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  headers: CloudFrontFunctionsHeaders;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * An object that represents the cookies in the request (`Cookie` headers).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * The `cookies` object contains one field for each cookie in the request. Cookie names are converted to lowercase.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cookies: CloudFrontFunctionsCookies;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ## Request object The request object contains a representation of a viewer-to-CloudFront HTTP request. In the event object that’s passed to your function, the request object represents the actual request that CloudFront received from the viewer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your function code returns a request object to CloudFront, it must use this same structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The request object contains the following fields: - method - uri - querystring - headers - cookies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  response: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * The HTTP status code of the response. This value is an integer, not a string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * If the function is associated with a _viewer response_ event type, your function code cannot change
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * the `statusCode` that it received. If the function is associated with a _viewer request_ event type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * and [generates an HTTP response](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/writing-function-code.html#function-code-generate-response),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * your function code can set the `statusCode`.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  statusCode: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** The HTTP status description of the response. If your function code generates a response, this field is optional. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  statusDescription?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * An object that represents the HTTP headers in the response. If the response contains any `Set-Cookie` headers,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * those `headers` are not part of the headers object. Cookies are represented separately in the `cookies` object.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * The `headers` object contains one field for each header in the response. Header names are converted to lowercase.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  headers: CloudFrontFunctionsHeaders;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * An object that represents the cookies in the response (`Set-Cookie` headers).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * The `cookies` object contains one field for each cookie in the response. Cookie names are converted to lowercase.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cookies: CloudFrontFunctionsCookies;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ## Response object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The response object contains a representation of a CloudFront-to-viewer HTTP response. In the event object that’s passed to your function, the response object represents CloudFront’s actual response to a viewer request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your function code returns a response object, it must use this same structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The response object contains the following fields:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  version: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ## Version field The version field contains a string that specifies the version of the CloudFront Functions event object. The current version is 1.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property viewer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  viewer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ip: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ## Viewer object The viewer object contains an ip field whose value is the IP address of the viewer (client) that sent the request. If the viewer request came through an HTTP proxy or a load balancer, the value is the IP address of the proxy or load balancer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloudFrontFunctionsHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloudFrontFunctionsHeaders {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-event-structure.html#functions-event-structure-query-header-cookie

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: { value: string; multiValue?: Array<{ value: string }> };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CloudFrontFunctionsQuerystring

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CloudFrontFunctionsQuerystring {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-event-structure.html#functions-event-structure-query-header-cookie

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: { value: string; multiValue?: Array<{ value: string }> };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CloudFrontHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CloudFrontHeaders {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • CloudFront events http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html Bear in mind that the "example" event structure in the page above includes both an S3 and a Custom origin, which is not strictly allowed. Only one of these per event may be present.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [name: string]: Array<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CloudFrontRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CloudFrontRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          body?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          action: 'read-only' | 'replace';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          encoding: 'base64' | 'text';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly inputTruncated: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property clientIp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly clientIp: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              headers: CloudFrontHeaders;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly method: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property origin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  origin?: CloudFrontOrigin | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property querystring

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    querystring: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property uri

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      uri: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CloudFrontRequestEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CloudFrontRequestEvent {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • CloudFront viewer request or origin request event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html#lambda-event-structure-request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Records

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Records: Array<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cf: CloudFrontEvent & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        request: CloudFrontRequest;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CloudFrontResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CloudFrontResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            headers: CloudFrontHeaders;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              status: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property statusDescription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                statusDescription: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloudFrontResponseEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloudFrontResponseEvent {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • CloudFront viewer response or origin response event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html#lambda-event-structure-response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Records

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Records: Array<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cf: CloudFrontEvent & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly request: Pick<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CloudFrontRequest,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Exclude<keyof CloudFrontRequest, 'body'>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  response: CloudFrontResponse;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CloudFrontResultResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CloudFrontResultResponse {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Generated HTTP response in viewer request event or origin request event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-generating-http-responses-in-requests.html#lambda-generating-http-responses-object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    body?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bodyEncoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bodyEncoding?: 'text' | 'base64' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        headers?: CloudFrontHeaders | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          status: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property statusDescription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            statusDescription?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CloudFrontS3Origin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CloudFrontS3Origin {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property authMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                authMethod: 'origin-access-identity' | 'none';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property customHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  customHeaders: CloudFrontHeaders;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property domainName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    domainName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property region

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        region: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CloudWatchLogsDecodedData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CloudWatchLogsDecodedData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property logEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            logEvents: CloudWatchLogsLogEvent[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property logGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              logGroup: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property logStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                logStream: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property messageType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  messageType: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property owner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    owner: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property subscriptionFilters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      subscriptionFilters: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CloudWatchLogsEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CloudWatchLogsEvent {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • See http://docs.aws.amazon.com/lambda/latest/dg/eventsources.html#eventsources-cloudwatch-logs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property awslogs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        awslogs: CloudWatchLogsEventData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CloudWatchLogsEventData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CloudWatchLogsEventData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CloudWatchLogsLogEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CloudWatchLogsLogEvent {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • See http://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SubscriptionFilters.html#LambdaFunctionExample

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property extractedFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extractedFields?: CloudWatchLogsLogEventExtractedFields | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property timestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timestamp: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CloudWatchLogsLogEventExtractedFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CloudWatchLogsLogEventExtractedFields {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [name: string]: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CodeBuildCloudWatchStateEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CodeBuildCloudWatchStateEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extends EventBridgeEvent<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'CodeBuild Build State Change',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CodeBuildStateEventDetail
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            source: 'aws.codebuild';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CodeBuildStateEventDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CodeBuildStateEventDetail {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property 'additional-information'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                '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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'compute-type': CodeBuildEnvironmentComputeType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: CodeBuildEnvironmentType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'environment-variables': Array<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type?: CodeBuildEnvironmentVariableType | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'project-file-system-locations': [];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                logs: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'group-name': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'stream-name': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'deep-link': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                phases: Array<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'phase-context'?: string[] | undefined; // Not available for COMPLETED phase-type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'start-time': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'end-time'?: string | undefined; // Not available for COMPLETED phase-type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'duration-in-seconds'?: number | undefined; // Not available for COMPLETED phase-type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'phase-type': CodeBuildPhaseType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'phase-status'?: CodeBuildPhaseStatusType | undefined; // Not available for COMPLETED phase-type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'queued-timeout-in-minutes': number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'build-id'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'build-id': string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property 'build-status'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'build-status': CodeBuildStateType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property 'current-phase-context'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'current-phase-context': string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'current-phase'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'current-phase': CodeBuildPhaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'project-name'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'project-name': string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CodePipelineCloudWatchActionEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CodePipelineCloudWatchActionEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property 'detail-type'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'detail-type': 'CodePipeline Action Execution State Change';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property account

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  account: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property region

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        region: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property resources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resources: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            source: 'aws.codepipeline';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              time: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CodePipelineCloudWatchPipelineEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CodePipelineCloudWatchPipelineEvent {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'detail-type'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'detail-type': 'CodePipeline Pipeline Execution State Change';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property account

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    account: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      detail: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pipeline: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      version: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      state: CodePipelineState;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'execution-id': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property region

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          region: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property resources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resources: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              source: 'aws.codepipeline';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                time: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CodePipelineCloudWatchStageEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CodePipelineCloudWatchStageEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property 'detail-type'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'detail-type': 'CodePipeline Stage Execution State Change';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property account

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        account: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          detail: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pipeline: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          version: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'execution-id': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stage: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          state: CodePipelineStageState;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property region

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              region: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property resources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                resources: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  source: 'aws.codepipeline';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    time: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CodePipelineEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CodePipelineEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'CodePipeline.job'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'CodePipeline.job': {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          accountId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          actionConfiguration: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          configuration: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          FunctionName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          UserParameters: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inputArtifacts: Artifact[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outputArtifacts: Artifact[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          artifactCredentials: Credentials;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          encryptionKey?: (EncryptionKey & { type: 'KMS' }) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          continuationToken?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CognitoIdentity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CognitoIdentity {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cognitoIdentityId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cognitoIdentityId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cognitoIdentityPoolId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cognitoIdentityPoolId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CognitoUserPoolTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CognitoUserPoolTriggerEvent {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Cognito User Pool event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Please use specific event types instead http://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property callerContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callerContext: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  awsSdkVersion: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  clientId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property region

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    region: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      request: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userAttributes: { [key: string]: string };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      validationData?: { [key: string]: string } | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      codeParameter?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      linkParameter?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      usernameParameter?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      newDeviceUsed?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      session?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Array<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      challengeName:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'CUSTOM_CHALLENGE'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'PASSWORD_VERIFIER'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'SMS_MFA'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'DEVICE_SRP_AUTH'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'DEVICE_PASSWORD_VERIFIER'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'ADMIN_NO_SRP_AUTH'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'SRP_A';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      challengeResult: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      challengeMetadata?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      challengeName?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      privateChallengeParameters?: { [key: string]: string } | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      challengeAnswer?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      password?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      clientMetadata?: { [key: string]: string } | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userNotFound?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        response: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        autoConfirmUser?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        autoVerifyPhone?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        autoVerifyEmail?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        smsMessage?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        emailMessage?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        emailSubject?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        challengeName?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        issueTokens?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        failAuthentication?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        publicChallengeParameters?: { [key: string]: string } | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        privateChallengeParameters?: { [key: string]: string } | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        challengeMetadata?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        answerCorrect?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        userAttributes?: { [key: string]: string } | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        finalUserStatus?: 'CONFIRMED' | 'RESET_REQUIRED' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        messageAction?: 'SUPPRESS' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        desiredDeliveryMediums?: Array<'EMAIL' | 'SMS'> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        forceAliasCreation?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        claimsOverrideDetails?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        claimsToAddOrOverride?: { [key: string]: string } | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        claimsToSuppress?: string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        groupOverrideDetails?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        groupsToOverride?: string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        iamRolesToOverride?: string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        preferredRole?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property triggerSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          triggerSource:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'PreSignUp_SignUp'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'PreSignUp_ExternalProvider'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'PostConfirmation_ConfirmSignUp'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'PreAuthentication_Authentication'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'PostAuthentication_Authentication'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CustomMessage_SignUp'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CustomMessage_AdminCreateUser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CustomMessage_ResendCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CustomMessage_ForgotPassword'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CustomMessage_UpdateUserAttribute'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CustomMessage_VerifyUserAttribute'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CustomMessage_Authentication'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'DefineAuthChallenge_Authentication'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CreateAuthChallenge_Authentication'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'VerifyAuthChallengeResponse_Authentication'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'PreSignUp_AdminCreateUser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'PostConfirmation_ConfirmForgotPassword'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'TokenGeneration_HostedAuth'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'TokenGeneration_Authentication'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'TokenGeneration_NewPasswordChallenge'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'TokenGeneration_AuthenticateDevice'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'TokenGeneration_RefreshTokens'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'UserMigration_Authentication'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'UserMigration_ForgotPassword';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property userName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userName?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property userPoolId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              userPoolId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                version: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Condition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Condition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConditionBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConditionBlock {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • API Gateway CustomAuthorizer AuthResponse.PolicyDocument.Condition. https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-policy-language-overview.html https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [condition: string]: Condition | Condition[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ConnectContactFlowEndpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ConnectContactFlowEndpoint {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Address: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type: 'TELEPHONE_NUMBER';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ConnectContactFlowEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ConnectContactFlowEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Details

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Details: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ContactData: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Attributes: { [key: string]: string };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Channel: ConnectContactFlowChannel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ContactId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CustomerEndpoint: ConnectContactFlowEndpoint | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                InitialContactId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                InitiationMethod: ConnectContactFlowInitiationMethod;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                InstanceARN: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                PreviousContactId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Queue: ConnectContactFlowQueue | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SystemEndpoint: ConnectContactFlowEndpoint | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MediaStreams: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Customer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Audio: CustomerAudio;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters: { [key: string]: string };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Name: 'ContactFlowEvent';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ConnectContactFlowQueue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ConnectContactFlowQueue {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ARN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ARN: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ConnectContactFlowResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ConnectContactFlowResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Context {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property awsRequestId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              awsRequestId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property callbackWaitsForEmptyEventLoop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callbackWaitsForEmptyEventLoop: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property clientContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  clientContext?: ClientContext | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property functionName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    functionName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property functionVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      functionVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property identity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        identity?: CognitoIdentity | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property invokedFunctionArn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          invokedFunctionArn: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property logGroupName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            logGroupName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property logStreamName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              logStreamName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property memoryLimitInMB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                memoryLimitInMB: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method done

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  done: (error?: Error, result?: any) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use handler callback or promise result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method fail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fail: (error: Error | string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use handler callback with first argument or reject a promise result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getRemainingTimeInMillis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getRemainingTimeInMillis: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method succeed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    succeed: { (messageOrObject: any): void; (message: string, object: any): void };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Use handler callback with second argument or resolve a promise result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Use handler callback or promise result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CreateAuthChallengeTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CreateAuthChallengeTriggerEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extends BaseTriggerEvent<'CreateAuthChallenge_Authentication'> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-lambda-create-auth-challenge.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    request: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    userAttributes: StringMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    challengeName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    session: Array<ChallengeResult | CustomChallengeResult>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clientMetadata?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    userNotFound?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      response: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      publicChallengeParameters: StringMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      privateChallengeParameters: StringMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      challengeMetadata: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Credentials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Credentials {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property accessKeyId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          accessKeyId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property secretAccessKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            secretAccessKey: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sessionToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sessionToken?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CustomAuthorizerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CustomAuthorizerEvent {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use APIGatewayAuthorizerEvent or a subtype

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property apiId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                apiId?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property authorizationToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  authorizationToken?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property domainName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    domainName?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      headers?: { [name: string]: string } | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property httpMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        httpMethod?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property methodArn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          methodArn: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property multiValueHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            multiValueHeaders?: { [name: string]: string[] } | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property multiValueQueryStringParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              multiValueQueryStringParameters?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | { [name: string]: string[] }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                path?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property pathParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pathParameters?: { [name: string]: string } | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property queryStringParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    queryStringParameters?: { [name: string]: string } | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property requestContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      requestContext?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | APIGatewayEventRequestContextWithAuthorizer<APIGatewayEventDefaultAuthorizerContext>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property resource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        resource?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property stageVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stageVariables?: { [name: string]: string } | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CustomEmailSender_AccountTakeOverNotification_UserAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CustomEmailSender_AccountTakeOverNotification_UserAttributes {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ACCOUNT_TAKE_OVER_ACTION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ACCOUNT_TAKE_OVER_ACTION: AccountTakeOverActionType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property CITY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CITY?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property COUNTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    COUNTRY?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property DEVICE_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DEVICE_NAME?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property EVENT_ID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        EVENT_ID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property FEEDBACK_TOKEN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          FEEDBACK_TOKEN: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property IP_ADDRESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            IP_ADDRESS: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property LOGIN_TIME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LOGIN_TIME: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ONE_CLICK_LINK_INVALID: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ONE_CLICK_LINK_VALID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property USER_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    USER_NAME: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CustomEmailSenderAccountTakeOverNotificationTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CustomEmailSenderAccountTakeOverNotificationTriggerEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      extends BaseTriggerEvent<'CustomEmailSender_AccountTakeOverNotification'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        request: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        code: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        userAttributes: CustomEmailSender_AccountTakeOverNotification_UserAttributes;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        clientMetadata?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CustomEmailSenderAdminCreateUserTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CustomEmailSenderAdminCreateUserTriggerEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extends BaseCustomEmailSenderTriggerEvent<'CustomEmailSender_AdminCreateUser'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CustomEmailSenderForgotPasswordTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CustomEmailSenderForgotPasswordTriggerEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extends BaseCustomEmailSenderTriggerEvent<'CustomEmailSender_ForgotPassword'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CustomEmailSenderResendCodeTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CustomEmailSenderResendCodeTriggerEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extends BaseCustomEmailSenderTriggerEvent<'CustomEmailSender_ResendCode'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CustomEmailSenderSignUpTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CustomEmailSenderSignUpTriggerEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extends BaseCustomEmailSenderTriggerEvent<'CustomEmailSender_SignUp'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CustomEmailSenderUpdateUserAttributeTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CustomEmailSenderUpdateUserAttributeTriggerEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  extends BaseCustomEmailSenderTriggerEvent<'CustomEmailSender_UpdateUserAttribute'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CustomEmailSenderVerifyUserAttributeTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CustomEmailSenderVerifyUserAttributeTriggerEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extends BaseCustomEmailSenderTriggerEvent<'CustomEmailSender_VerifyUserAttribute'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DefineAuthChallengeTriggerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DefineAuthChallengeTriggerEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      extends BaseTriggerEvent<'DefineAuthChallenge_Authentication'> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-lambda-define-auth-challenge.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      request: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userAttributes: StringMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      session: Array<ChallengeResult | CustomChallengeResult>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      clientMetadata?: StringMap | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userNotFound?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        response: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        challengeName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        failAuthentication: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        issueTokens: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DynamoDBRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DynamoDBRecord {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property awsRegion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            awsRegion?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property dynamodb

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dynamodb?: StreamRecord | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property eventID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                eventID?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property eventName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  eventName?: 'INSERT' | 'MODIFY' | 'REMOVE' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property eventSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    eventSource?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property eventSourceARN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eventSourceARN?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property eventVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        eventVersion?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property userIdentity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          userIdentity?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DynamoDBStreamEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DynamoDBStreamEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Records

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Records: DynamoDBRecord[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EncryptionKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EncryptionKey {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface EventBridgeEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface EventBridgeEvent<TDetailType extends string, TDetail> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'detail-type'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'detail-type': TDetailType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property account

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          account: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            detail: TDetail;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property region

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                region: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property resources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  resources: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      time: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface FirehoseRecordMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface FirehoseRecordMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property approximateArrivalTimestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            approximateArrivalTimestamp: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property partitionKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              partitionKey: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property sequenceNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sequenceNumber: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property shardId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  shardId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property subsequenceNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    subsequenceNumber: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FirehoseTransformationEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FirehoseTransformationEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property deliveryStreamArn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        deliveryStreamArn: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property invocationId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          invocationId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property records

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            records: FirehoseTransformationEventRecord[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property region

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              region: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FirehoseTransformationEventRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FirehoseTransformationEventRecord {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property approximateArrivalTimestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  approximateArrivalTimestamp: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    data: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Base64 encoded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kinesisRecordMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kinesisRecordMetadata?: FirehoseRecordMetadata | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property recordId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      recordId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <