cdk-drizzle-migrate 0.0.9

package/lib/handler/index.d.ts

@@ -0,0 +1,8 @@
+import { CloudFormationCustomResourceEvent } from "aws-lambda";
+interface CustomResourceResponse {
+    PhysicalResourceId?: string;
+    Data?: any;
+    NoEcho?: boolean;
+}
+export declare function handler(event: CloudFormationCustomResourceEvent): Promise<CustomResourceResponse>;
+export {};

package/lib/handler/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = handler;
+const handler_js_1 = require("./handler.js");
+async function handler(event) {
+    return (0, handler_js_1.onEvent)(event);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGFuZGxlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVNBLDBCQUlDO0FBWkQsNkNBQXNDO0FBUS9CLEtBQUssVUFBVSxPQUFPLENBQzNCLEtBQXdDO0lBRXhDLE9BQU8sSUFBQSxvQkFBTyxFQUFDLEtBQUssQ0FBQyxDQUFBO0FBQ3ZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDbG91ZEZvcm1hdGlvbkN1c3RvbVJlc291cmNlRXZlbnQgfSBmcm9tIFwiYXdzLWxhbWJkYVwiXG5pbXBvcnQgeyBvbkV2ZW50IH0gZnJvbSBcIi4vaGFuZGxlci5qc1wiXG5cbmludGVyZmFjZSBDdXN0b21SZXNvdXJjZVJlc3BvbnNlIHtcbiAgUGh5c2ljYWxSZXNvdXJjZUlkPzogc3RyaW5nXG4gIERhdGE/OiBhbnlcbiAgTm9FY2hvPzogYm9vbGVhblxufVxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gaGFuZGxlcihcbiAgZXZlbnQ6IENsb3VkRm9ybWF0aW9uQ3VzdG9tUmVzb3VyY2VFdmVudFxuKTogUHJvbWlzZTxDdXN0b21SZXNvdXJjZVJlc3BvbnNlPiB7XG4gIHJldHVybiBvbkV2ZW50KGV2ZW50KVxufVxuIl19

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from "./drizzle-migrate-provider";

package/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./drizzle-migrate-provider"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDZEQUEwQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2RyaXp6bGUtbWlncmF0ZS1wcm92aWRlclwiXG4iXX0=

package/node_modules/@types/aws-lambda/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/node_modules/@types/aws-lambda/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/aws-lambda`
+
+# Summary
+This package contains type definitions for aws-lambda (http://docs.aws.amazon.com/lambda).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/aws-lambda.
+
+### Additional Details
+ * Last updated: Fri, 03 Jan 2025 00:04:09 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [James Darbyshire](https://github.com/darbio), [Michael Skarum](https://github.com/skarum), [Stef Heyenrath](https://github.com/StefH), [Rich Buggy](https://github.com/buggy), [wwwy3y3](https://github.com/wwwy3y3), [Ishaan Malhi](https://github.com/OrthoDex), [Michael Marner](https://github.com/MichaelMarner), [Daniel Cottone](https://github.com/daniel-cottone), [Kostya Misura](https://github.com/kostya-misura), [Markus Tacker](https://github.com/coderbyheart), [Palmi Valgeirsson](https://github.com/palmithor), [Danilo Raisi](https://github.com/daniloraisi), [Simon Buchan](https://github.com/simonbuchan), [David Hayden](https://github.com/Haydabase), [Chris Redekop](https://github.com/repl-chris), [Aneil Mallavarapu](https://github.com/aneilbaboo), [Jeremy Nagel](https://github.com/jeznag), [Louis Larry](https://github.com/louislarry), [Daniel Papukchiev](https://github.com/dpapukchiev), [Oliver Hookins](https://github.com/ohookins), [Trevor Leach](https://github.com/trevor-leach), [James Gregory](https://github.com/jagregory), [Erik Dalén](https://github.com/dalen), [Loïk Gaonac'h](https://github.com/loikg), [Roberto Zen](https://github.com/skyzenr), [Grzegorz Redlicki](https://github.com/redlickigrzegorz), [Juan Carbonel](https://github.com/juancarbonel), [Peter McIntyre](https://github.com/pwmcintyre), [Alex Bolenok](https://github.com/alex-bolenok-centralreach), [Marian Zange](https://github.com/marianzange), [Alessandro Palumbo](https://github.com/apalumbo), [Sachin Shekhar](https://github.com/SachinShekhar), [Ivan Martos](https://github.com/ivanmartos), [Zach Anthony](https://github.com/zach-anthony), [Peter Savnik](https://github.com/savnik), [Benoit Boure](https://github.com/bboure), [James Lakin](https://github.com/jamesorlakin), [Ross Gerbasi](https://github.com/aphex), [Joey Kilpatrick](https://github.com/joeykilpatrick), [Luciano Manerich Junior](https://github.com/lmanerich), and [Luciano M. Taranto](https://github.com/LucianoTaranto).

package/node_modules/@types/aws-lambda/common/api-gateway.d.ts

@@ -0,0 +1,83 @@
+// Types shared between trigger/api-gateway-authorizer.d.ts and api-gateway-proxy.d.ts
+
+// Poorly documented, but API Gateway will just fail internally if
+// the context type does not match this.
+// Note that although non-string types will be accepted, they will be
+// coerced to strings on the other side.
+export interface APIGatewayAuthorizerResultContext {
+    [name: string]: string | number | boolean | null | undefined;
+}
+
+// Default authorizer type, prefer using a specific type with the "...WithAuthorizer..." variant types.
+// Note that this doesn't have to be a context from a custom lambda outhorizer, AWS also has a cognito
+// authorizer type and could add more, so the property won't always be a string.
+export type APIGatewayEventDefaultAuthorizerContext =
+    | undefined
+    | null
+    | {
+        [name: string]: any;
+    };
+
+export type APIGatewayEventRequestContext = APIGatewayEventRequestContextWithAuthorizer<
+    APIGatewayEventDefaultAuthorizerContext
+>;
+
+// The requestContext property of both request authorizer and proxy integration events.
+export interface APIGatewayEventRequestContextWithAuthorizer<TAuthorizerContext> {
+    accountId: string;
+    apiId: string;
+    // This one is a bit confusing: it is not actually present in authorizer calls
+    // and proxy calls without an authorizer. We model this by allowing undefined in the type,
+    // since it ends up the same and avoids breaking users that are testing the property.
+    // This lets us allow parameterizing the authorizer for proxy events that know what authorizer
+    // context values they have.
+    authorizer: TAuthorizerContext;
+    connectedAt?: number | undefined;
+    connectionId?: string | undefined;
+    domainName?: string | undefined;
+    domainPrefix?: string | undefined;
+    eventType?: string | undefined;
+    extendedRequestId?: string | undefined;
+    protocol: string;
+    httpMethod: string;
+    identity: APIGatewayEventIdentity;
+    messageDirection?: string | undefined;
+    messageId?: string | null | undefined;
+    path: string;
+    stage: string;
+    requestId: string;
+    requestTime?: string | undefined;
+    requestTimeEpoch: number;
+    resourceId: string;
+    resourcePath: string;
+    routeKey?: string | undefined;
+}
+
+export interface APIGatewayEventClientCertificate {
+    clientCertPem: string;
+    serialNumber: string;
+    subjectDN: string;
+    issuerDN: string;
+    validity: {
+        notAfter: string;
+        notBefore: string;
+    };
+}
+
+export interface APIGatewayEventIdentity {
+    accessKey: string | null;
+    accountId: string | null;
+    apiKey: string | null;
+    apiKeyId: string | null;
+    caller: string | null;
+    clientCert: APIGatewayEventClientCertificate | null;
+    cognitoAuthenticationProvider: string | null;
+    cognitoAuthenticationType: string | null;
+    cognitoIdentityId: string | null;
+    cognitoIdentityPoolId: string | null;
+    principalOrgId: string | null;
+    sourceIp: string;
+    user: string | null;
+    userAgent: string | null;
+    userArn: string | null;
+}

package/node_modules/@types/aws-lambda/common/cloudfront.d.ts

@@ -0,0 +1,245 @@
+/**
+ * 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.
+ */
+export interface CloudFrontHeaders {
+    [name: string]: Array<{
+        key?: string | undefined;
+        value: string;
+    }>;
+}
+
+export type CloudFrontOrigin =
+    | { s3: CloudFrontS3Origin; custom?: never | undefined }
+    | { custom: CloudFrontCustomOrigin; s3?: never | undefined };
+
+export interface CloudFrontCustomOrigin {
+    customHeaders: CloudFrontHeaders;
+    domainName: string;
+    keepaliveTimeout: number;
+    path: string;
+    port: number;
+    protocol: "http" | "https";
+    readTimeout: number;
+    sslProtocols: string[];
+}
+
+export type CloudFrontS3Origin =
+    | CloudFrontS3OriginAuthMethodNone
+    | CloudFrontS3OriginAuthMethodOriginAccessIdentity;
+
+export interface CloudFrontS3OriginBase {
+    authMethod: "origin-access-identity" | "none";
+    customHeaders: CloudFrontHeaders;
+    domainName: string;
+    path: string;
+}
+
+export interface CloudFrontS3OriginAuthMethodNone extends CloudFrontS3OriginBase {
+    authMethod: "none";
+    region?: never;
+}
+
+export interface CloudFrontS3OriginAuthMethodOriginAccessIdentity extends CloudFrontS3OriginBase {
+    authMethod: "origin-access-identity";
+    region: string;
+}
+
+export interface CloudFrontResponse {
+    status: string;
+    statusDescription: string;
+    headers: CloudFrontHeaders;
+}
+
+export interface CloudFrontRequest {
+    body?:
+        | {
+            action: "read-only" | "replace";
+            data: string;
+            encoding: "base64" | "text";
+            readonly inputTruncated: boolean;
+        }
+        | undefined;
+    readonly clientIp: string;
+    readonly method: string;
+    uri: string;
+    querystring: string;
+    headers: CloudFrontHeaders;
+    origin?: CloudFrontOrigin | undefined;
+}
+
+export interface CloudFrontEvent {
+    config: {
+        readonly distributionDomainName: string;
+        readonly distributionId: string;
+        readonly eventType: "origin-request" | "origin-response" | "viewer-request" | "viewer-response";
+        readonly requestId: string;
+    };
+}
+
+/**
+ * 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
+ */
+export interface CloudFrontResultResponse {
+    status: string;
+    statusDescription?: string | undefined;
+    headers?: CloudFrontHeaders | undefined;
+    bodyEncoding?: "text" | "base64" | undefined;
+    body?: string | undefined;
+}
+
+/** @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-event-structure.html#functions-event-structure-query-header-cookie */
+export interface CloudFrontFunctionsCookies {
+    [key: string]: {
+        value: string;
+        attributes?: string;
+        multiValue?: Array<{ value: string; attributes?: string }>;
+    };
+}
+
+/** @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-event-structure.html#functions-event-structure-query-header-cookie */
+export interface CloudFrontFunctionsQuerystring {
+    [key: string]: { value: string; multiValue?: Array<{ value: string }> };
+}
+
+/** @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-event-structure.html#functions-event-structure-query-header-cookie */
+export interface CloudFrontFunctionsHeaders {
+    [key: string]: { value: string; multiValue?: Array<{ value: string }> };
+}
+
+/**
+ * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-event-structure.html
+ *
+ * @usage
+ * ```ts
+ * 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
+ * };
+ * ```
+ */
+export interface CloudFrontFunctionsEvent {
+    /**
+     * ## Version field
+     * The version field contains a string that specifies the version of the
+     * CloudFront Functions event object. The current version is 1.0.
+     */
+    version: string;
+    /**
+     * ## Context object
+     * The `context` object contains contextual information about the event. It includes the following fields:
+     * - `distributionDomainName`
+     * - `distributionId`
+     * - `eventType`
+     * - `requestId`
+     */
+    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;
+    };
+    /**
+     * ## 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.
+     */
+    viewer: {
+        ip: string;
+    };
+    /**
+     * ## 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`
+     */
+    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;
+    };
+    /**
+     * ## 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:
+     */
+    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;
+    };
+}

package/node_modules/@types/aws-lambda/handler.d.ts

@@ -0,0 +1,172 @@
+/**
+ * The interface that AWS Lambda will invoke your handler with.
+ * There are more specialized types for many cases where AWS services
+ * invoke your lambda, but you can directly use this type for when you are invoking
+ * your lambda directly.
+ *
+ * See the {@link http://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html AWS documentation}
+ * for more information about the runtime behavior, and the
+ * {@link https://aws.amazon.com/blogs/compute/node-js-8-10-runtime-now-available-in-aws-lambda/ AWS Blog post}
+ * introducing the async handler behavior in the 8.10 runtime.
+ *
+ * @example <caption>Defining a custom handler type</caption>
+ * import { Handler } from 'aws-lambda'
+ *
+ * interface NameEvent {
+ *     fullName: string
+ * }
+ * interface NameResult {
+ *     firstName: string
+ *     middleNames: string
+ *     lastName: string
+ * }
+ * type PersonHandler = Handler<NameEvent, NameResult>
+ *
+ * export const handler: PersonHandler = async (event) => {
+ *   const names = event.fullName.split(' ')
+ *   const firstName = names.shift()
+ *   const lastName = names.pop()
+ *   return { firstName, middleNames: names, lastName }
+ * }
+ *
+ * @example <caption>Logs the contents of the event object and returns the location of the logs</caption>
+ * import { Handler } from 'aws-lambda'
+ *
+ * export const handler: Handler = async (event, context) => {
+ *   console.log("EVENT: \n" + JSON.stringify(event, null, 2))
+ *   return context.logStreamName
+ * }
+ *
+ * @example <caption>AWS SDK with Async Function and Promises</caption>
+ * import { Handler } from 'aws-lambda'
+ * import AWS from 'aws-sdk'
+ *
+ * const s3 = new AWS.S3()
+ *
+ * export const handler: Handler = async (event) => {
+ *   const response = await s3.listBuckets().promise()
+ *   return response?.Buckets.map((bucket) => bucket.Name)
+ * }
+ *
+ * @example <caption>HTTP Request with Callback</caption>
+ * import { Handler } from 'aws-lambda'
+ * import https from 'https'
+ *
+ * let url = "https://docs.aws.amazon.com/lambda/latest/dg/welcome.html"
+ *
+ * export const handler: Handler<void, number> = (event, context, callback) => {
+ *  https.get(url, (res) => {
+ *    callback(null, res.statusCode)
+ *  }).on('error', (e) => {
+ *    callback(Error(e))
+ *  })
+ * }
+ *
+ * @param event
+ *      Parsed JSON data in the lambda request payload. For an AWS service triggered
+ *      lambda this should be in the format of a type ending in Event, for example the
+ *      S3Handler receives an event of type S3Event.
+ * @param context
+ *      Runtime contextual information of the current invocation, for example the caller
+ *      identity, available memory and time remaining, legacy completion callbacks, and
+ *      a mutable property controlling when the lambda execution completes.
+ * @param callback
+ *      NodeJS-style completion callback that the AWS Lambda runtime will provide that can
+ *      be used to provide the lambda result payload value, or any execution error. Can
+ *      instead return a promise that resolves with the result payload value or rejects
+ *      with the execution error.
+ * @return
+ *      A promise that resolves with the lambda result payload value, or rejects with the
+ *      execution error. Note that if you implement your handler as an async function,
+ *      you will automatically return a promise that will resolve with a returned value,
+ *      or reject with a thrown value.
+ */
+export type Handler<TEvent = any, TResult = any> = (
+    event: TEvent,
+    context: Context,
+    callback: Callback<TResult>,
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+) => void | Promise<TResult>;
+
+/**
+ * {@link Handler} context parameter.
+ * See {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html AWS documentation}.
+ */
+export interface Context {
+    callbackWaitsForEmptyEventLoop: boolean;
+    functionName: string;
+    functionVersion: string;
+    invokedFunctionArn: string;
+    memoryLimitInMB: string;
+    awsRequestId: string;
+    logGroupName: string;
+    logStreamName: string;
+    identity?: CognitoIdentity | undefined;
+    clientContext?: ClientContext | undefined;
+
+    getRemainingTimeInMillis(): number;
+
+    // Functions for compatibility with earlier Node.js Runtime v0.10.42
+    // No longer documented, so they are deprecated, but they still work
+    // as of the 12.x runtime, so they are not removed from the types.
+
+    /** @deprecated Use handler callback or promise result */
+    done(error?: Error, result?: any): void;
+    /** @deprecated Use handler callback with first argument or reject a promise result */
+    fail(error: Error | string): void;
+    /** @deprecated Use handler callback with second argument or resolve a promise result */
+    succeed(messageOrObject: any): void;
+    // Unclear what behavior this is supposed to have, I couldn't find any still extant reference,
+    // and it behaves like the above, ignoring the object parameter.
+    /** @deprecated Use handler callback or promise result */
+    succeed(message: string, object: any): void;
+}
+
+export interface CognitoIdentity {
+    cognitoIdentityId: string;
+    cognitoIdentityPoolId: string;
+}
+
+export interface ClientContext {
+    client: ClientContextClient;
+    Custom?: any;
+    env: ClientContextEnv;
+}
+
+export interface ClientContextClient {
+    installationId: string;
+    appTitle: string;
+    appVersionName: string;
+    appVersionCode: string;
+    appPackageName: string;
+}
+
+export interface ClientContextEnv {
+    platformVersion: string;
+    platform: string;
+    make: string;
+    model: string;
+    locale: string;
+}
+
+/**
+ * NodeJS-style callback parameter for the {@link Handler} type.
+ * Can be used instead of returning a promise, see the
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html AWS documentation}
+ * for the handler programming model.
+ *
+ * @param error
+ *   Parameter to use to provide the error payload for a failed lambda execution.
+ *   See {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-mode-exceptions.html AWS documentation}
+ *   for error handling.
+ *   If an Error instance is passed, the error payload uses the `name` property as the `errorType`,
+ *   the `message` property as the `errorMessage`, and parses the `stack` property string into
+ *   the `trace` array.
+ *   For other values, the `errorType` is `typeof value`, the `errorMessage` is `String(value)`, and
+ *   `trace` is an empty array.
+ *
+ * @param result
+ *   Parameter to use to provide the result payload for a successful lambda execution.
+ *   Pass `null` or `undefined` for the `error` parameter to use this parameter.
+ */
+export type Callback<TResult = any> = (error?: Error | string | null, result?: TResult) => void;

package/node_modules/@types/aws-lambda/index.d.ts

@@ -0,0 +1,54 @@
+export * from "./common/api-gateway";
+export * from "./common/cloudfront";
+export * from "./handler";
+export * from "./trigger/alb";
+// TODO: export * from "./trigger/alexa";
+export * from "./trigger/api-gateway-authorizer";
+export * from "./trigger/api-gateway-proxy";
+export * from "./trigger/appsync-resolver";
+export * from "./trigger/autoscaling";
+// CloudTrail section just describes using S3 to trigger on cloudtrail changes.
+export * from "./trigger/cdk-custom-resource";
+export * from "./trigger/cloudformation-custom-resource";
+export * from "./trigger/cloudfront-request";
+export * from "./trigger/cloudfront-response";
+export * from "./trigger/cloudwatch-alarm";
+export * from "./trigger/cloudwatch-events";
+export * from "./trigger/cloudwatch-logs";
+export * from "./trigger/codebuild-cloudwatch-state";
+export * from "./trigger/codecommit";
+export * from "./trigger/codepipeline";
+export * from "./trigger/codepipeline-cloudwatch";
+export * from "./trigger/codepipeline-cloudwatch-action";
+export * from "./trigger/codepipeline-cloudwatch-pipeline";
+export * from "./trigger/codepipeline-cloudwatch-stage";
+// TODO: export * from "./trigger/cognito-sync";
+export * from "./trigger/cognito-user-pool-trigger/";
+export * from "./trigger/connect-contact-flow";
+// TODO: export * from "./trigger/config";
+export * from "./trigger/dynamodb-stream";
+export * from "./trigger/eventbridge";
+// ElastiCache section just describes using lambdas in an ElastiCache context (VPC issues, etc.)
+// EC2 events are delivered using cloudwatch events...
+export * from "./trigger/guard-duty-event-notification";
+export * from "./trigger/iot";
+export * from "./trigger/iot-authorizer";
+export * from "./trigger/kinesis-firehose-transformation";
+export * from "./trigger/kinesis-stream";
+export * from "./trigger/lambda-function-url";
+export * from "./trigger/lex";
+export * from "./trigger/lex-v2";
+// RDS events are delivered using SNS events...
+export * from "./trigger/amplify-resolver";
+export * from "./trigger/msk";
+export * from "./trigger/s3";
+export * from "./trigger/s3-batch";
+export * from "./trigger/s3-event-notification";
+export * from "./trigger/secretsmanager";
+export * from "./trigger/self-managed-kafka";
+export * from "./trigger/ses";
+export * from "./trigger/sns";
+export * from "./trigger/sqs";
+export * from "./trigger/transfer-family-authorizer";
+
+export as namespace AWSLambda;