declare let str: string; declare let strOrNull: string | null; declare let strOrUndefined: string | undefined; declare let strOrUndefinedOrNull: string | undefined | null; declare let date: Date; declare let anyObj: any; declare let num: number; declare let error: Error; declare let bool: boolean; declare let boolOrUndefined: boolean | undefined; declare let boolOrNumOrStr: boolean | number | string; declare let numOrUndefined: number | undefined; declare let apiGwEvtReqCtx: AWSLambda.APIGatewayEventRequestContext; declare let apiGwEvtReqCtxOpt: AWSLambda.APIGatewayEventRequestContext | null | undefined; declare let apiGwEvt: AWSLambda.APIGatewayEvent; declare let albEvtReqCtx: AWSLambda.ALBEventRequestContext; declare let albEvt: AWSLambda.ALBEvent; declare let albRes: AWSLambda.ALBResult; declare let customAuthorizerEvt: AWSLambda.CustomAuthorizerEvent; declare let clientCtx: AWSLambda.ClientContext; declare let clientCtxOrUndefined: AWSLambda.ClientContext | undefined; declare let clientContextEnv: AWSLambda.ClientContextEnv; declare let clientContextClient: AWSLambda.ClientContextClient; declare let context: AWSLambda.Context; declare let identity: AWSLambda.CognitoIdentity; declare let identityOrUndefined: AWSLambda.CognitoIdentity | undefined; declare let proxyResult: AWSLambda.ProxyResult; declare let authResponse: AWSLambda.AuthResponse; declare let policyDocument: AWSLambda.PolicyDocument; declare let statement: AWSLambda.Statement; declare let authResponseContext: AWSLambda.AuthResponseContext; declare let authResponseContextOpt: AWSLambda.AuthResponseContext | null | undefined; declare let snsEvt: AWSLambda.SNSEvent; declare let snsEvtRecs: AWSLambda.SNSEventRecord[]; declare let snsEvtRec: AWSLambda.SNSEventRecord; declare let snsMsg: AWSLambda.SNSMessage; declare let snsMsgAttr: AWSLambda.SNSMessageAttribute; declare let snsMsgAttrs: AWSLambda.SNSMessageAttributes; const S3EvtRec: AWSLambda.S3EventRecord = { eventVersion: '2.1', eventSource: 'aws:s3', awsRegion: 'us-east-1', eventTime: '1970-01-01T00:00:00.000Z', eventName: 'ObjectRestore:Completed', userIdentity: { principalId: 'AIDAJDPLRKLG7UEXAMPLE', }, requestParameters: { sourceIPAddress: '127.0.0.1', }, responseElements: { 'x-amz-request-id': 'C3D13FE58DE4C810', 'x-amz-id-2': 'FMyUVURIY8/IgAtTv8xRjskZQpcIZ9KG4V5Wp6S7S/JRWeUWerMUE5JgHvANOjpD', }, s3: { s3SchemaVersion: '1.0', configurationId: 'testConfigRule', bucket: { name: 'mybucket', ownerIdentity: { principalId: 'A3NL1KOZZKExample', }, arn: 'arn:aws:s3:::mybucket', }, object: { key: 'HappyFace.jpg', size: 1024, eTag: 'd41d8cd98f00b204e9800998ecf8427e', versionId: '096fKKXTRTtl3on89fVO.nfljtsv6qko', sequencer: '0055AED6DCD90281E5', }, }, glacierEventData: { restoreEventData: { lifecycleRestorationExpiryTime: '1970-01-01T00:00:00.000Z', lifecycleRestoreStorageClass: 'glacier-deep-archive', }, }, }; const S3CreateEvent: AWSLambda.S3CreateEvent = { Records: [S3EvtRec], }; declare const cognitoUserPoolEvent: AWSLambda.CognitoUserPoolEvent; declare const cloudformationCustomResourceEvent: AWSLambda.CloudFormationCustomResourceEvent; declare const cloudformationCustomResourceResponse: AWSLambda.CloudFormationCustomResourceResponse; declare const cloudwatchLogsEvent: AWSLambda.CloudWatchLogsEvent; declare const cloudwatchLogsDecodedData: AWSLambda.CloudWatchLogsDecodedData; declare const scheduledEvent: AWSLambda.ScheduledEvent; /* API Gateway Event request context */ str = apiGwEvtReqCtx.accountId; str = apiGwEvtReqCtx.apiId; authResponseContextOpt = apiGwEvtReqCtx.authorizer; numOrUndefined = apiGwEvtReqCtx.connectedAt; strOrUndefined = apiGwEvtReqCtx.connectionId; strOrUndefined = apiGwEvtReqCtx.domainName; strOrUndefined = apiGwEvtReqCtx.eventType; strOrUndefined = apiGwEvtReqCtx.extendedRequestId; str = apiGwEvtReqCtx.httpMethod; strOrNull = apiGwEvtReqCtx.identity.accessKey; strOrNull = apiGwEvtReqCtx.identity.accountId; strOrNull = apiGwEvtReqCtx.identity.apiKey; strOrNull = apiGwEvtReqCtx.identity.apiKeyId; strOrNull = apiGwEvtReqCtx.identity.caller; strOrNull = apiGwEvtReqCtx.identity.cognitoAuthenticationProvider; strOrNull = apiGwEvtReqCtx.identity.cognitoAuthenticationType; strOrNull = apiGwEvtReqCtx.identity.cognitoIdentityId; strOrNull = apiGwEvtReqCtx.identity.cognitoIdentityPoolId; strOrNull = apiGwEvtReqCtx.identity.principalOrgId; str = apiGwEvtReqCtx.identity.sourceIp; strOrNull = apiGwEvtReqCtx.identity.user; strOrNull = apiGwEvtReqCtx.identity.userAgent; strOrNull = apiGwEvtReqCtx.identity.userArn; strOrUndefined = apiGwEvtReqCtx.messageDirection; strOrUndefinedOrNull = apiGwEvtReqCtx.messageId; str = apiGwEvtReqCtx.path; str = apiGwEvtReqCtx.stage; str = apiGwEvtReqCtx.requestId; strOrUndefined = apiGwEvtReqCtx.requestTime; str = apiGwEvtReqCtx.resourceId; str = apiGwEvtReqCtx.resourcePath; strOrUndefined = apiGwEvtReqCtx.routeKey; /* API Gateway Event */ strOrNull = apiGwEvt.body; str = apiGwEvt.headers['example']; str = apiGwEvt.multiValueHeaders['example'][0]; str = apiGwEvt.httpMethod; bool = apiGwEvt.isBase64Encoded; str = apiGwEvt.path; str = apiGwEvt.pathParameters!['example']; str = apiGwEvt.queryStringParameters!['example']; str = apiGwEvt.multiValueQueryStringParameters!['example'][0]; str = apiGwEvt.stageVariables!['example']; apiGwEvtReqCtx = apiGwEvt.requestContext; str = apiGwEvt.resource; /* Application Load Balancer Event Request Context */ str = albEvtReqCtx.elb.targetGroupArn; /* Application Load Balancer Event */ str = albEvt.httpMethod; str = albEvt.path; str = albEvt.queryStringParameters!['example']; str = albEvt.headers!['example']; str = albEvt.multiValueQueryStringParameters!['example'][0]; str = albEvt.multiValueHeaders!['example'][0]; strOrNull = albEvt.body; bool = albEvt.isBase64Encoded; /* Application Load Balancer Result */ num = albRes.statusCode; str = albRes.statusDescription; boolOrNumOrStr = albRes.headers!['example']; boolOrNumOrStr = albRes.multiValueHeaders!['example'][0]; strOrUndefined = albRes.body; bool = albRes.isBase64Encoded; /* API Gateway CustomAuthorizer Event */ str = customAuthorizerEvt.type; str = customAuthorizerEvt.methodArn; strOrUndefined = customAuthorizerEvt.authorizationToken; strOrUndefined = customAuthorizerEvt.resource; strOrUndefined = customAuthorizerEvt.path; strOrUndefined = customAuthorizerEvt.httpMethod; str = customAuthorizerEvt.headers!['example']; str = customAuthorizerEvt.multiValueHeaders!['example'][0]; str = customAuthorizerEvt.pathParameters!['example']; str = customAuthorizerEvt.queryStringParameters!['example']; str = customAuthorizerEvt.multiValueQueryStringParameters!['example'][0]; str = customAuthorizerEvt.stageVariables!['example']; apiGwEvtReqCtxOpt = customAuthorizerEvt.requestContext; strOrUndefined = customAuthorizerEvt.domainName; strOrUndefined = customAuthorizerEvt.apiId; /* DynamoDB Stream Event */ const dynamoDBStreamEvent: AWSLambda.DynamoDBStreamEvent = { Records: [ { eventID: '1', eventVersion: '1.0', dynamodb: { Keys: { Id: { N: '101', }, }, NewImage: { Message: { S: 'New item!', }, Id: { N: '101', }, }, StreamViewType: 'NEW_AND_OLD_IMAGES', SequenceNumber: '111', SizeBytes: 26, }, awsRegion: 'us-west-2', eventName: 'INSERT', eventSourceARN: 'arn:aws:dynamodb:us-west-2:account-id:table/ExampleTableWithStream/stream/2015-06-27T00:48:05.899', eventSource: 'aws:dynamodb', }, { eventID: '2', eventVersion: '1.0', dynamodb: { OldImage: { Message: { S: 'New item!', }, Id: { N: '101', }, }, SequenceNumber: '222', Keys: { Id: { N: '101', }, }, SizeBytes: 59, NewImage: { Message: { S: 'This item has changed', }, Id: { N: '101', }, }, StreamViewType: 'NEW_AND_OLD_IMAGES', }, awsRegion: 'us-west-2', eventName: 'MODIFY', eventSourceARN: 'arn:aws:dynamodb:us-west-2:account-id:table/ExampleTableWithStream/stream/2015-06-27T00:48:05.899', eventSource: 'aws:dynamodb', }, { eventID: '3', eventVersion: '1.0', dynamodb: { Keys: { Id: { N: '101', }, }, SizeBytes: 38, SequenceNumber: '333', OldImage: { Message: { S: 'This item has changed', }, Id: { N: '101', }, }, StreamViewType: 'NEW_AND_OLD_IMAGES', }, awsRegion: 'us-west-2', eventName: 'REMOVE', eventSourceARN: 'arn:aws:dynamodb:us-west-2:account-id:table/ExampleTableWithStream/stream/2015-06-27T00:48:05.899', eventSource: 'aws:dynamodb', }, ], }; /* SNS Event */ snsEvtRecs = snsEvt.Records; str = snsEvtRec.EventSource; str = snsEvtRec.EventSubscriptionArn; str = snsEvtRec.EventVersion; snsMsg = snsEvtRec.Sns; str = snsMsg.SignatureVersion; str = snsMsg.Timestamp; str = snsMsg.Signature; str = snsMsg.SigningCertUrl; str = snsMsg.MessageId; str = snsMsg.Message; snsMsgAttrs = snsMsg.MessageAttributes; str = snsMsg.Type; str = snsMsg.UnsubscribeUrl; str = snsMsg.TopicArn; str = snsMsg.Subject; snsMsgAttrs['example'] = snsMsgAttr; str = snsMsgAttr.Type; str = snsMsgAttr.Value; /* Lambda Proxy Result */ num = proxyResult.statusCode; proxyResult.headers!['example'] = str; proxyResult.headers!['example'] = bool; proxyResult.headers!['example'] = num; proxyResult.multiValueHeaders!['example'][0] = str; proxyResult.multiValueHeaders!['example'][0] = bool; proxyResult.multiValueHeaders!['example'][0] = num; boolOrUndefined = proxyResult.isBase64Encoded; str = proxyResult.body; /* API Gateway CustomAuthorizer AuthResponse */ authResponseContext = { stringKey: str, numberKey: num, booleanKey: bool, }; statement = { Action: str, Effect: str, Resource: str, }; // $ExpectError statement = { Effect: str, Action: str, Principal: 123, }; // Bad Resource // $ExpectError statement = { Effect: str, Action: str, Resource: 123, }; // Bad Resource with valid Principal // $ExpectError statement = { Effect: str, Action: str, Principal: { Service: str }, Resource: 123, }; // Bad principal with valid Resource // $ExpectError statement = { Effect: str, Action: str, Principal: 123, Resource: str, }; // No Effect // $ExpectError statement = { Action: str, Principal: str, }; statement = { Sid: str, Action: [str, str], Effect: str, Resource: [str, str], Condition: { condition1: { key: 'value' }, condition2: [ { key1: 'value', key2: 'value', }, { key3: 'value', }, ], }, Principal: [str, str], NotPrincipal: [str, str], }; statement = { Action: str, Principal: str, Effect: str, }; statement = { Action: str, NotPrincipal: { Service: str, }, Effect: str, }; statement = { Effect: str, NotAction: str, NotResource: str, }; policyDocument = { Version: str, Statement: [statement], }; policyDocument = { Version: str, Statement: [statement, statement], }; authResponse = { principalId: str, policyDocument, context: authResponseContext, }; authResponse = { principalId: str, policyDocument, }; // CognitoUserPoolEvent num = cognitoUserPoolEvent.version; cognitoUserPoolEvent.triggerSource === 'PreSignUp_SignUp'; cognitoUserPoolEvent.triggerSource === 'PreSignUp_ExternalProvider'; cognitoUserPoolEvent.triggerSource === 'PostConfirmation_ConfirmSignUp'; cognitoUserPoolEvent.triggerSource === 'PreAuthentication_Authentication'; cognitoUserPoolEvent.triggerSource === 'PostAuthentication_Authentication'; cognitoUserPoolEvent.triggerSource === 'CustomMessage_SignUp'; cognitoUserPoolEvent.triggerSource === 'CustomMessage_AdminCreateUser'; cognitoUserPoolEvent.triggerSource === 'CustomMessage_ResendCode'; cognitoUserPoolEvent.triggerSource === 'CustomMessage_ForgotPassword'; cognitoUserPoolEvent.triggerSource === 'CustomMessage_UpdateUserAttribute'; cognitoUserPoolEvent.triggerSource === 'CustomMessage_VerifyUserAttribute'; cognitoUserPoolEvent.triggerSource === 'CustomMessage_Authentication'; cognitoUserPoolEvent.triggerSource === 'DefineAuthChallenge_Authentication'; cognitoUserPoolEvent.triggerSource === 'CreateAuthChallenge_Authentication'; cognitoUserPoolEvent.triggerSource === 'VerifyAuthChallengeResponse_Authentication'; cognitoUserPoolEvent.triggerSource === 'PreSignUp_AdminCreateUser'; cognitoUserPoolEvent.triggerSource === 'PostConfirmation_ConfirmForgotPassword'; cognitoUserPoolEvent.triggerSource === 'TokenGeneration_HostedAuth'; cognitoUserPoolEvent.triggerSource === 'TokenGeneration_Authentication'; cognitoUserPoolEvent.triggerSource === 'TokenGeneration_NewPasswordChallenge'; cognitoUserPoolEvent.triggerSource === 'TokenGeneration_AuthenticateDevice'; cognitoUserPoolEvent.triggerSource === 'TokenGeneration_RefreshTokens'; cognitoUserPoolEvent.triggerSource === 'UserMigration_Authentication'; cognitoUserPoolEvent.triggerSource === 'UserMigration_ForgotPassword'; str = cognitoUserPoolEvent.region; str = cognitoUserPoolEvent.userPoolId; strOrUndefined = cognitoUserPoolEvent.userName; str = cognitoUserPoolEvent.callerContext.awsSdkVersion; str = cognitoUserPoolEvent.callerContext.clientId; str = cognitoUserPoolEvent.request.userAttributes['email']; str = cognitoUserPoolEvent.request.validationData!['k1']; strOrUndefined = cognitoUserPoolEvent.request.codeParameter; strOrUndefined = cognitoUserPoolEvent.request.linkParameter; strOrUndefined = cognitoUserPoolEvent.request.usernameParameter; boolOrUndefined = cognitoUserPoolEvent.request.newDeviceUsed; cognitoUserPoolEvent.request.session![0].challengeName === 'CUSTOM_CHALLENGE'; cognitoUserPoolEvent.request.session![0].challengeName === 'PASSWORD_VERIFIER'; cognitoUserPoolEvent.request.session![0].challengeName === 'SMS_MFA'; cognitoUserPoolEvent.request.session![0].challengeName === 'DEVICE_SRP_AUTH'; cognitoUserPoolEvent.request.session![0].challengeName === 'DEVICE_PASSWORD_VERIFIER'; cognitoUserPoolEvent.request.session![0].challengeName === 'ADMIN_NO_SRP_AUTH'; bool = cognitoUserPoolEvent.request.session![0].challengeResult; strOrUndefined = cognitoUserPoolEvent.request.session![0].challengeMetadata; strOrUndefined = cognitoUserPoolEvent.request.challengeName; str = cognitoUserPoolEvent.request.privateChallengeParameters!['answer']; str = cognitoUserPoolEvent.request.challengeAnswer!; strOrUndefined = cognitoUserPoolEvent.request.password; boolOrUndefined = cognitoUserPoolEvent.response.answerCorrect; strOrUndefined = cognitoUserPoolEvent.response.smsMessage; strOrUndefined = cognitoUserPoolEvent.response.emailMessage; strOrUndefined = cognitoUserPoolEvent.response.emailSubject; strOrUndefined = cognitoUserPoolEvent.response.challengeName; boolOrUndefined = cognitoUserPoolEvent.response.issueTokens; boolOrUndefined = cognitoUserPoolEvent.response.failAuthentication; str = cognitoUserPoolEvent.response.publicChallengeParameters!['captchaUrl']; str = cognitoUserPoolEvent.response.privateChallengeParameters!['answer']; strOrUndefined = cognitoUserPoolEvent.response.challengeMetadata; boolOrUndefined = cognitoUserPoolEvent.response.answerCorrect; str = cognitoUserPoolEvent.response.userAttributes!['username']; cognitoUserPoolEvent.response.finalUserStatus === 'CONFIRMED'; cognitoUserPoolEvent.response.finalUserStatus === 'RESET_REQUIRED'; cognitoUserPoolEvent.response.messageAction === 'SUPPRESS'; cognitoUserPoolEvent.response.desiredDeliveryMediums === ['EMAIL']; cognitoUserPoolEvent.response.desiredDeliveryMediums === ['SMS']; cognitoUserPoolEvent.response.desiredDeliveryMediums === ['SMS', 'EMAIL']; boolOrUndefined = cognitoUserPoolEvent.response.forceAliasCreation; // From AWS examples cognitoUserPoolEvent.response = { claimsOverrideDetails: { claimsToAddOrOverride: { attribute_key2: 'attribute_value2', attribute_key: 'attribute_value', }, claimsToSuppress: ['email'], }, }; cognitoUserPoolEvent.response = { claimsOverrideDetails: { claimsToAddOrOverride: { attribute_key2: 'attribute_value2', attribute_key: 'attribute_value', }, claimsToSuppress: ['email'], groupOverrideDetails: { groupsToOverride: ['group-A', 'group-B', 'group-C'], iamRolesToOverride: [ 'arn:aws:iam::XXXXXXXXXXXX:role/sns_callerA', 'arn:aws:iam::XXXXXXXXX:role/sns_callerB', 'arn:aws:iam::XXXXXXXXXX:role/sns_callerC', ], preferredRole: 'arn:aws:iam::XXXXXXXXXXX:role/sns_caller', }, }, }; cognitoUserPoolEvent.response.claimsOverrideDetails!.groupOverrideDetails = null; // CloudFormation Custom Resource switch (cloudformationCustomResourceEvent.RequestType) { case 'Create': str = cloudformationCustomResourceEvent.LogicalResourceId; str = cloudformationCustomResourceEvent.RequestId; anyObj = cloudformationCustomResourceEvent.ResourceProperties; str = cloudformationCustomResourceEvent.ResourceProperties.ServiceToken; str = cloudformationCustomResourceEvent.ResourceType; str = cloudformationCustomResourceEvent.ResponseURL; str = cloudformationCustomResourceEvent.ServiceToken; str = cloudformationCustomResourceEvent.StackId; break; case 'Update': anyObj = cloudformationCustomResourceEvent.OldResourceProperties; break; case 'Delete': str = cloudformationCustomResourceEvent.PhysicalResourceId; break; } anyObj = cloudformationCustomResourceResponse.Data; str = cloudformationCustomResourceResponse.LogicalResourceId; str = cloudformationCustomResourceResponse.PhysicalResourceId; strOrUndefined = cloudformationCustomResourceResponse.Reason; str = cloudformationCustomResourceResponse.RequestId; str = cloudformationCustomResourceResponse.StackId; str = cloudformationCustomResourceResponse.Status; boolOrUndefined = cloudformationCustomResourceResponse.NoEcho; /* ScheduledEvent */ str = scheduledEvent.account; anyObj = scheduledEvent.detail; str = scheduledEvent.id; str = scheduledEvent.region; str = scheduledEvent.resources[0]; str = scheduledEvent.source; str = scheduledEvent.time; /* Context */ bool = context.callbackWaitsForEmptyEventLoop; str = context.functionName; str = context.functionVersion; str = context.invokedFunctionArn; str = context.memoryLimitInMB; str = context.awsRequestId; str = context.logGroupName; str = context.logStreamName; identityOrUndefined = context.identity; clientCtxOrUndefined = context.clientContext; /* CognitoIdentity */ str = identity.cognitoIdentityId; str = identity.cognitoIdentityPoolId; /* CloudWatch Logs */ str = cloudwatchLogsEvent.awslogs.data; str = cloudwatchLogsDecodedData.owner; str = cloudwatchLogsDecodedData.logGroup; str = cloudwatchLogsDecodedData.logStream; str = cloudwatchLogsDecodedData.subscriptionFilters[0]; str = cloudwatchLogsDecodedData.messageType; str = cloudwatchLogsDecodedData.logEvents[0].id; num = cloudwatchLogsDecodedData.logEvents[0].timestamp; str = cloudwatchLogsDecodedData.logEvents[0].message; str = cloudwatchLogsDecodedData.logEvents[0].extractedFields!['example']; /* ClientContext */ clientContextClient = clientCtx.client; anyObj = clientCtx.Custom; clientContextEnv = clientCtx.env; /* ClientContextEnv */ str = clientContextEnv.locale; str = clientContextEnv.make; str = clientContextEnv.model; str = clientContextEnv.platform; str = clientContextEnv.platformVersion; /* ClientContextClient */ str = clientContextClient.appPackageName; str = clientContextClient.appTitle; str = clientContextClient.appVersionCode; str = clientContextClient.appVersionName; str = clientContextClient.installationId; /* Callback */ function callback(cb: AWSLambda.Callback) { cb(); cb(null); cb(error); cb(str); // https://docs.aws.amazon.com/apigateway/latest/developerguide/handle-errors-in-lambda-integration.html cb(null, anyObj); cb(null, bool); cb(null, str); cb(null, num); } /* Proxy Callback */ function proxyCallback(cb: AWSLambda.ProxyCallback) { cb(); cb(null); cb(error); cb(null, proxyResult); } /* CustomAuthorizerCallback */ function customAuthorizerCallback(cb: AWSLambda.CustomAuthorizerCallback) { cb(); cb(null); cb(error); cb(null, authResponse); } /* CodePipeline events https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-invoke-lambda-function.html#actions-invoke-lambda-function-json-event-example */ const CodePipelineEvent: AWSLambda.CodePipelineEvent = { 'CodePipeline.job': { id: '11111111-abcd-1111-abcd-111111abcdef', accountId: '111111111111', data: { actionConfiguration: { configuration: { FunctionName: 'MyLambdaFunctionForAWSCodePipeline', UserParameters: 'some-input-such-as-a-URL', }, }, inputArtifacts: [ { location: { s3Location: { bucketName: 'the name of the bucket configured as the pipeline artifact store in Amazon S3, for example codepipeline-us-east-2-1234567890', objectKey: 'the name of the application, for example CodePipelineDemoApplication.zip', }, type: 'S3', }, revision: null, name: 'ArtifactName', }, ], outputArtifacts: [], artifactCredentials: { secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY', sessionToken: `MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w 0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5 jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw 3rrszlaEXAMPLE=`, accessKeyId: 'AKIAIOSFODNN7EXAMPLE', }, continuationToken: 'A continuation token if continuing job', }, }, }; CodePipelineEvent['CodePipeline.job'].data.encryptionKey = { type: 'KMS', id: 'key' }; /* CodePipeline CloudWatch Events * see https://docs.aws.amazon.com/codepipeline/latest/userguide/detect-state-changes-cloudwatch-events.html * Their documentation says that detail.version is a string, but it is actually an integer */ const CodePipelineCloudWatchEvent: AWSLambda.CodePipelineCloudWatchEvent = { version: '0', id: 'event_Id', 'detail-type': 'CodePipeline Pipeline Execution State Change', source: 'aws.codepipeline', account: 'Pipeline_Account', time: 'TimeStamp', region: 'us-east-1', resources: ['arn:aws:codepipeline:us-east-1:account_ID:myPipeline'], detail: { pipeline: 'myPipeline', version: 1, state: 'STARTED', 'execution-id': 'execution_Id', }, }; /* CloudFront events, see http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html */ const CloudFrontRequestWithCustomOriginEvent: AWSLambda.CloudFrontRequestEvent = { Records: [ { cf: { config: { distributionDomainName: 'd123.cloudfront.net', distributionId: 'EDFDVBD6EXAMPLE', eventType: 'viewer-request', requestId: 'MRVMF7KydIvxMWfJIglgwHQwZsbG2IhRJ07sn9AkKUFSHS9EXAMPLE==', }, request: { body: { action: 'read-only', data: 'eyJ1c2VybmFtZSI6IkxhbWJkYUBFZGdlIiwiY29tbWVudCI6IlRoaXMgaXMgcmVxdWVzdCBib2R5In0=', encoding: 'base64', inputTruncated: false, }, clientIp: '2001:0db8:85a3:0:0:8a2e:0370:7334', querystring: 'size=large', uri: '/picture.jpg', method: 'GET', headers: { host: [ { key: 'Host', value: 'd111111abcdef8.cloudfront.net', }, ], 'user-agent': [ { key: 'User-Agent', value: 'curl/7.51.0', }, ], }, origin: { custom: { customHeaders: { 'my-origin-custom-header': [ { key: 'My-Origin-Custom-Header', value: 'Test', }, ], }, domainName: 'example.com', keepaliveTimeout: 5, path: '/custom_path', port: 443, protocol: 'https', readTimeout: 5, sslProtocols: ['TLSv1', 'TLSv1.1'], }, }, }, }, }, ], }; const CloudFrontRequestWithS3OriginEvent: AWSLambda.CloudFrontRequestEvent = { Records: [ { cf: { config: { distributionDomainName: 'd123.cloudfront.net', distributionId: 'EDFDVBD6EXAMPLE', eventType: 'viewer-request', requestId: 'MRVMF7KydIvxMWfJIglgwHQwZsbG2IhRJ07sn9AkKUFSHS9EXAMPLE==', }, request: { body: { action: 'read-only', data: 'eyJ1c2VybmFtZSI6IkxhbWJkYUBFZGdlIiwiY29tbWVudCI6IlRoaXMgaXMgcmVxdWVzdCBib2R5In0=', encoding: 'base64', inputTruncated: false, }, clientIp: '2001:0db8:85a3:0:0:8a2e:0370:7334', querystring: 'size=large', uri: '/picture.jpg', method: 'GET', headers: { host: [ { key: 'Host', value: 'd111111abcdef8.cloudfront.net', }, ], 'user-agent': [ { key: 'User-Agent', value: 'curl/7.51.0', }, ], }, origin: { s3: { authMethod: 'origin-access-identity', customHeaders: { 'my-origin-custom-header': [ { key: 'My-Origin-Custom-Header', value: 'Test', }, ], }, domainName: 'my-bucket.s3.amazonaws.com', path: '/s3_path', region: 'us-east-1', }, }, }, }, }, ], }; const CloudFrontResponseEvent: AWSLambda.CloudFrontResponseEvent = { Records: [ { cf: { config: { distributionDomainName: 'd123.cloudfront.net', distributionId: 'EDFDVBD6EXAMPLE', eventType: 'viewer-response', requestId: 'xGN7KWpVEmB9Dp7ctcVFQC4E-nrcOcEKS3QyAez--06dV7TEXAMPLE==', }, request: { clientIp: '2001:0db8:85a3:0:0:8a2e:0370:7334', method: 'GET', uri: '/picture.jpg', querystring: 'size=large', headers: { host: [ { key: 'Host', value: 'd111111abcdef8.cloudfront.net', }, ], 'user-agent': [ { key: 'User-Agent', value: 'curl/7.18.1', }, ], }, }, response: { status: '200', statusDescription: 'OK', headers: { server: [ { key: 'Server', value: 'MyCustomOrigin', }, ], 'set-cookie': [ { key: 'Set-Cookie', value: 'theme=light', }, { key: 'Set-Cookie', value: 'sessionToken=abc123; Expires=Wed, 09 Jun 2021 10:18:14 GMT', }, ], }, }, }, }, ], }; /* Kinesis Data Stream Events */ declare let kinesisStreamEvent: AWSLambda.KinesisStreamEvent; declare let kinesisStreamRecord: AWSLambda.KinesisStreamRecord; declare let kinesisStreamRecordPayload: AWSLambda.KinesisStreamRecordPayload; kinesisStreamRecord = kinesisStreamEvent.Records[0]; str = kinesisStreamRecord.awsRegion; str = kinesisStreamRecord.eventID; str = kinesisStreamRecord.eventName; str = kinesisStreamRecord.eventSource; str = kinesisStreamRecord.eventSourceARN; str = kinesisStreamRecord.eventVersion; str = kinesisStreamRecord.invokeIdentityArn; kinesisStreamRecordPayload = kinesisStreamRecord.kinesis; num = kinesisStreamRecordPayload.approximateArrivalTimestamp; str = kinesisStreamRecordPayload.data; str = kinesisStreamRecordPayload.kinesisSchemaVersion; str = kinesisStreamRecordPayload.partitionKey; str = kinesisStreamRecordPayload.sequenceNumber; /* Compatibility functions */ context.done(); context.done(error); context.done(error, anyObj); context.succeed(str); context.succeed(anyObj); context.succeed(str, anyObj); context.fail(error); context.fail(str); /* Handler */ const handler: AWSLambda.Handler = (event: any, context: AWSLambda.Context, cb: AWSLambda.Callback) => {}; /* In node8.10 runtime, handlers may return a promise for the result value, so existing async * handlers that return Promise before calling the callback will now have a `null` result. * Be safe and make that badly typed with a major verson bump to 8.10 so users expect the breaking change, * since the upgrade effort should be pretty low in most cases, and it points them at a nicer solution. */ // $ExpectError const legacyAsyncHandler: AWSLambda.APIGatewayProxyHandler = async ( event: AWSLambda.APIGatewayProxyEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => { cb(null, { statusCode: 200, body: 'No longer valid' }); }; const node8AsyncHandler: AWSLambda.APIGatewayProxyHandler = async ( event: AWSLambda.APIGatewayProxyEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => { return { statusCode: 200, body: 'Is now valid!' }; }; const inferredHandler: AWSLambda.S3Handler = (event, context, cb) => { // $ExpectType S3Event event; str = event.Records[0].eventName; // $ExpectType Context context; str = context.functionName; // $ExpectType Callback cb; cb(); cb(null); cb(new Error()); // $ExpectError cb(null, {}); }; // Test using default Callback type still works. const defaultCallbackHandler: AWSLambda.APIGatewayProxyHandler = ( event: AWSLambda.APIGatewayEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; const albSyncHandler: AWSLambda.ALBHandler = ( event: AWSLambda.ALBEvent, context: AWSLambda.Context, cb: AWSLambda.ALBCallback, ) => { cb(null, { statusCode: 200, statusDescription: '200 OK', headers: {}, body: '', isBase64Encoded: false, }); }; const albAsyncHandler: AWSLambda.ALBHandler = async ( event: AWSLambda.ALBEvent, context: AWSLambda.Context, cb: AWSLambda.ALBCallback, ) => { return { statusCode: 200, statusDescription: '200 OK', headers: {}, body: '', isBase64Encoded: false, }; }; // Specific types let s3Handler: AWSLambda.S3Handler = ( event: AWSLambda.S3Event, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; // Test old name const s3CreateHandler: AWSLambda.S3Handler = ( event: AWSLambda.S3CreateEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; s3Handler = s3CreateHandler; const dynamoDBStreamHandler: AWSLambda.DynamoDBStreamHandler = ( event: AWSLambda.DynamoDBStreamEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; const snsHandler: AWSLambda.SNSHandler = ( event: AWSLambda.SNSEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; const cognitoUserPoolHandler: AWSLambda.CognitoUserPoolTriggerHandler = ( event: AWSLambda.CognitoUserPoolEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; const cloudFormationCustomResourceHandler: AWSLambda.CloudFormationCustomResourceHandler = ( event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; const cloudWatchLogsHandler: AWSLambda.CloudWatchLogsHandler = ( event: AWSLambda.CloudWatchLogsEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; const scheduledHandler: AWSLambda.ScheduledHandler = ( event: AWSLambda.ScheduledEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; let apiGtwProxyHandler: AWSLambda.APIGatewayProxyHandler = ( event: AWSLambda.APIGatewayProxyEvent, context: AWSLambda.Context, cb: AWSLambda.APIGatewayProxyCallback, ) => {}; // Test old names const proxyHandler: AWSLambda.ProxyHandler = ( event: AWSLambda.APIGatewayEvent, context: AWSLambda.Context, cb: AWSLambda.ProxyCallback, ) => {}; apiGtwProxyHandler = proxyHandler; const codePipelineHandler: AWSLambda.CodePipelineHandler = ( event: AWSLambda.CodePipelineEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; const cloudFrontRequestHandler: AWSLambda.CloudFrontRequestHandler = ( event: AWSLambda.CloudFrontRequestEvent, context: AWSLambda.Context, cb: AWSLambda.CloudFrontRequestCallback, ) => { event = CloudFrontRequestWithCustomOriginEvent; // $ExpectType CloudFrontRequestEvent event; let request = event.Records[0].cf.request; let s3Origin: AWSLambda.CloudFrontS3Origin = { authMethod: 'none', customHeaders: {}, domainName: 'example.com', path: '/', region: 'us-east-1', }; if (request.origin && request.origin.custom) { request.origin.custom.domainName; request.origin.custom.domainName = 'example2.com'; // $ExpectError s3Origin = request.origin.s3; // $ExpectError request.origin.s3.path = '/'; } let customOrigin: AWSLambda.CloudFrontCustomOrigin = { customHeaders: {}, domainName: 'example.com', keepaliveTimeout: 60, path: '/', port: 80, protocol: 'http', readTimeout: 30, sslProtocols: [], }; event = CloudFrontRequestWithS3OriginEvent; // $ExpectType CloudFrontRequestEvent event; request = event.Records[0].cf.request; if (request.origin && request.origin.s3) { request.origin.s3.path; request.origin.s3.path = '/new_path'; // $ExpectError customOrigin = request.origin.custom; // $ExpectError request.origin.custom.path = '/'; } cb(); cb(null); cb(new Error('')); cb(null, { clientIp: str, method: str, uri: str, querystring: str, headers: {} }); cb(null, { status: str }); // $ExpectError cb(null, {}); }; const cloudFrontResponseHandler: AWSLambda.CloudFrontResponseHandler = ( event: AWSLambda.CloudFrontResponseEvent, context: AWSLambda.Context, cb: AWSLambda.CloudFrontResponseCallback, ) => {}; const cloudFrontHeaders: AWSLambda.CloudFrontHeaders = { 'content-type': [{ value: 'text/plain' }], 'x-foo-bar': [{ key: 'X-Foo-Bar', value: 'example' }], }; const customAuthorizerHandler: AWSLambda.CustomAuthorizerHandler = ( event: AWSLambda.CustomAuthorizerEvent, context: AWSLambda.Context, cb: AWSLambda.CustomAuthorizerCallback, ) => {}; interface CustomEvent { eventString: string; eventBool: boolean; } interface CustomResult { resultString: string; resultBool?: boolean; } type CustomCallback = AWSLambda.Callback; const customHandler: AWSLambda.Handler = (event, context, cb) => { // $ExpectType CustomEvent event; str = event.eventString; bool = event.eventBool; // $ExpectType Context context; // $ExpectType Callback cb; cb(null, { resultString: str, resultBool: bool }); // $ExpectError cb(null, { resultString: bool }); }; const kinesisStreamHandler: AWSLambda.KinesisStreamHandler = ( event: AWSLambda.KinesisStreamEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; const SQSMessageHandler: AWSLambda.SQSHandler = ( event: AWSLambda.SQSEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => {}; // See https://docs.aws.amazon.com/lambda/latest/dg/eventsources.html#eventsources-sqs const SQSEvent: AWSLambda.SQSEvent = { Records: [ { messageId: 'c80e8021-a70a-42c7-a470-796e1186f753', receiptHandle: 'AQEBJQ+/u6NsnT5t8Q/VbVxgdUl4TMKZ5FqhksRdIQvLBhwNvADoBxYSOVeCBXdnS9P+', body: '{"foo":"bar"}', attributes: { ApproximateReceiveCount: '3', SentTimestamp: '1529104986221', SenderId: '594035263019', ApproximateFirstReceiveTimestamp: '1529104986230', }, messageAttributes: { testAttr: { stringValue: '100', binaryValue: 'base64Str', stringListValues: [], binaryListValues: [], dataType: 'Number', }, }, md5OfBody: '9bb58f26192e4ba00f01e2e7b136bbd8', eventSource: 'aws:sqs', eventSourceARN: 'arn:aws:sqs:us-west-2:594035263019:NOTFIFOQUEUE', awsRegion: 'us-west-2', }, ], }; const SQSMessageLegacyAsyncHandler: AWSLambda.SQSHandler = async ( event: AWSLambda.SQSEvent, context: AWSLambda.Context, cb: AWSLambda.Callback, ) => { // $ExpectType SQSEvent event; str = event.Records[0].messageId; anyObj = event.Records[0].body; // $ExpectType Context context; str = context.functionName; // $ExpectType Callback cb; cb(); cb(null); cb(new Error()); }; const SQSMessageNode8AsyncHandler: AWSLambda.SQSHandler = async ( event: AWSLambda.SQSEvent, context: AWSLambda.Context, ) => { // $ExpectType SQSEvent event; str = event.Records[0].messageId; anyObj = event.Records[0].body; strOrUndefined = event.Records[0].messageAttributes.testAttr.stringValue; strOrUndefined = event.Records[0].messageAttributes.testAttr.binaryValue; str = event.Records[0].messageAttributes.testAttr.dataType; // $ExpectType Context context; str = context.functionName; return; }; const firehoseEventHandler: AWSLambda.FirehoseTransformationHandler = ( event: AWSLambda.FirehoseTransformationEvent, context: AWSLambda.Context, callback: AWSLambda.FirehoseTransformationCallback, ) => { // $ExpectType FirehoseTransformationEvent event; str = event.records[0].recordId; // $ExpectType Context context; str = context.functionName; callback(null, { records: [ { recordId: event.records[0].recordId, result: 'Ok' as AWSLambda.FirehoseRecordTransformationStatus, data: 'eyJmb28iOiJiYXIifQ==', }, ], }); }; declare let lexEvent: AWSLambda.LexEvent; lexEvent = { currentIntent: { name: 'intent-name', slots: { slot1: null, slot2: 'value2', }, slotDetails: { slot1: { resolutions: [{ value: 'value1' }], originalValue: 'originalValue', }, }, confirmationStatus: 'None', }, bot: { name: 'bot name', alias: 'bot alias', version: 'bot version', }, userId: 'User ID specified in the POST request to Amazon Lex.', inputTranscript: 'Text used to process the request', invocationSource: 'FulfillmentCodeHook', outputDialogMode: 'Text', messageVersion: '1.0', sessionAttributes: { key1: 'value1', key2: 'value2', }, requestAttributes: { key1: 'value1', key2: 'value2', }, }; declare let lexResult: AWSLambda.LexResult; declare let lexDialogAction: AWSLambda.LexDialogAction; declare let lexDialogActionBase: AWSLambda.LexDialogActionBase; declare let lexDialogActionClose: AWSLambda.LexDialogActionClose; declare let lexDialogActionConfirmIntent: AWSLambda.LexDialogActionConfirmIntent; declare let lexDialogActionDelegate: AWSLambda.LexDialogActionDelegate; declare let lexDialogActionElicitIntent: AWSLambda.LexDialogActionElicitIntent; declare let lexDialogActionElicitSlot: AWSLambda.LexDialogActionElicitSlot; declare let lexGenericAttachment: AWSLambda.LexGenericAttachment; lexResult = { sessionAttributes: { attrib1: 'Value One', }, dialogAction: { type: 'Close', fulfillmentState: 'Failed', }, }; str = lexGenericAttachment.title; str = lexGenericAttachment.subTitle; str = lexGenericAttachment.imageUrl; str = lexGenericAttachment.attachmentLinkUrl; str = lexGenericAttachment.buttons[0].text; str = lexGenericAttachment.buttons[0].value; lexDialogAction.type === 'Close'; lexDialogAction.type === 'ConfirmIntent'; lexDialogAction.type === 'Delegate'; lexDialogAction.type === 'ElicitIntent'; lexDialogAction.type === 'ElicitSlot'; lexDialogActionBase.message!.contentType === 'CustomPayload'; lexDialogActionBase.message!.contentType === 'PlainText'; lexDialogActionBase.message!.contentType === 'SSML'; str = lexDialogActionBase.message!.content; num = lexDialogActionBase.responseCard!.version; lexDialogActionBase.responseCard!.contentType === 'application/vnd.amazonaws.card.generic'; // $ExpectType LexGenericAttachment lexDialogActionBase.responseCard!.genericAttachments[0]; lexDialogActionClose.type === 'Close'; lexDialogActionClose.fulfillmentState === 'Failed'; lexDialogActionClose.fulfillmentState === 'Fulfilled'; lexDialogActionConfirmIntent.type === 'ConfirmIntent'; str = lexDialogActionConfirmIntent.intentName; strOrNull = lexDialogActionConfirmIntent.slots['example']; lexDialogActionDelegate.type === 'Delegate'; strOrNull = lexDialogActionDelegate.slots['example']; lexDialogActionElicitIntent.type === 'ElicitIntent'; lexDialogActionElicitSlot.type === 'ElicitSlot'; strOrNull = lexDialogActionElicitSlot.slots['example']; str = lexDialogActionElicitSlot.slotToElicit; str = lexDialogActionElicitSlot.intentName; const lexEventHandler: AWSLambda.LexHandler = async (event: AWSLambda.LexEvent, context: AWSLambda.Context) => { // $ExpectType LexEvent event; // $ExpectType Context context; str = context.functionName; return lexResult; }; /** * S3 Batch Operations event * https://docs.aws.amazon.com/AmazonS3/latest/dev/batch-ops-invoke-lambda.html */ const S3BatchEvent: AWSLambda.S3BatchEvent = { invocationSchemaVersion: '1.0', invocationId: 'foo_invocation_id', job: { id: 'foo_job_id' }, tasks: [ { taskId: '11111', s3Key: 'example.json', s3BucketArn: 'arn:aws:s3:::foo-bucket', s3VersionId: null, }, { taskId: '11111', s3Key: 'example.json', s3BucketArn: 'arn:aws:s3:::foo-bucket', s3VersionId: 'asdf', }, ], }; const S3BatchResult: AWSLambda.S3BatchResult = { invocationSchemaVersion: '1.0', treatMissingKeysAs: 'PermanentFailure', invocationId: 'foo_invocation_id', results: [ { taskId: '11111', resultCode: 'Succeeded', resultString: 'foo', }, { taskId: '22222', resultCode: 'TemporaryFailure', resultString: 'Error: failure', }, { taskId: '33333', resultCode: 'PermanentFailure', resultString: 'Error: failure', }, ], }; const S3BatchHandler: AWSLambda.S3BatchHandler = async (event: AWSLambda.S3BatchEvent, context: AWSLambda.Context) => { // $ExpectType S3BatchEvent event; // $ExpectType Context context; str = context.functionName; return S3BatchResult; };