@types/aws-lambda

  • Version 8.10.83
  • Published
  • 104 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 AppSyncAuthorizerEvent

                                                                                                                                                                                                                                                                                                                                      interface AppSyncAuthorizerEvent {}

                                                                                                                                                                                                                                                                                                                                        property authorizationToken

                                                                                                                                                                                                                                                                                                                                        authorizationToken: string;

                                                                                                                                                                                                                                                                                                                                          property requestContext

                                                                                                                                                                                                                                                                                                                                          requestContext: {
                                                                                                                                                                                                                                                                                                                                          apiId: string;
                                                                                                                                                                                                                                                                                                                                          accountId: string;
                                                                                                                                                                                                                                                                                                                                          requestId: string;
                                                                                                                                                                                                                                                                                                                                          queryString: string;
                                                                                                                                                                                                                                                                                                                                          variables: { [key: string]: any };
                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                            interface AppSyncAuthorizerResult

                                                                                                                                                                                                                                                                                                                                            interface AppSyncAuthorizerResult<TResolverContext = undefined> {}

                                                                                                                                                                                                                                                                                                                                              property deniedFields

                                                                                                                                                                                                                                                                                                                                              deniedFields?: string[];

                                                                                                                                                                                                                                                                                                                                                property isAuthorized

                                                                                                                                                                                                                                                                                                                                                isAuthorized: boolean;

                                                                                                                                                                                                                                                                                                                                                  property resolverContext

                                                                                                                                                                                                                                                                                                                                                  resolverContext?: TResolverContext;

                                                                                                                                                                                                                                                                                                                                                    property ttlOverride

                                                                                                                                                                                                                                                                                                                                                    ttlOverride?: number;

                                                                                                                                                                                                                                                                                                                                                      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 AppSyncIdentityLambda

                                                                                                                                                                                                                                                                                                                                                                                        interface AppSyncIdentityLambda {}

                                                                                                                                                                                                                                                                                                                                                                                          property resolverContext

                                                                                                                                                                                                                                                                                                                                                                                          resolverContext: any;

                                                                                                                                                                                                                                                                                                                                                                                            interface AppSyncIdentityOIDC

                                                                                                                                                                                                                                                                                                                                                                                            interface AppSyncIdentityOIDC {}

                                                                                                                                                                                                                                                                                                                                                                                              property claims

                                                                                                                                                                                                                                                                                                                                                                                              claims: any;

                                                                                                                                                                                                                                                                                                                                                                                                property issuer

                                                                                                                                                                                                                                                                                                                                                                                                issuer: string;

                                                                                                                                                                                                                                                                                                                                                                                                  property sub

                                                                                                                                                                                                                                                                                                                                                                                                  sub: 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?: AppSyncIdentity;

                                                                                                                                                                                                                                                                                                                                                                                                        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