cdk-drizzle-migrate 0.0.9

package/node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/user-migration.d.ts

@@ -0,0 +1,40 @@
+import { Handler } from "../../handler";
+import { BaseTriggerEvent, StringMap } from "./_common";
+
+export type UserStatus =
+    | "UNCONFIRMED"
+    | "CONFIRMED"
+    | "ARCHIVED"
+    | "COMPROMISED"
+    | "UNKNOWN"
+    | "RESET_REQUIRED"
+    | "FORCE_CHANGE_PASSWORD";
+
+export interface BaseUserMigrationTriggerEvent<T extends string> extends BaseTriggerEvent<T> {
+    request: {
+        password: string;
+        validationData?: StringMap | undefined;
+        clientMetadata?: StringMap | undefined;
+    };
+    response: {
+        userAttributes: StringMap;
+        finalUserStatus?: UserStatus | undefined;
+        messageAction?: "RESEND" | "SUPPRESS" | undefined;
+        desiredDeliveryMediums: Array<"SMS" | "EMAIL">;
+        forceAliasCreation?: boolean | undefined;
+        enableSMSMFA?: boolean | undefined;
+    };
+}
+
+export type UserMigrationAuthenticationTriggerEvent = BaseUserMigrationTriggerEvent<"UserMigration_Authentication">;
+
+export type UserMigrationForgotPasswordTriggerEvent = BaseUserMigrationTriggerEvent<"UserMigration_ForgotPassword">;
+
+/**
+ * @see https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-lambda-migrate-user.html
+ */
+export type UserMigrationTriggerEvent =
+    | UserMigrationAuthenticationTriggerEvent
+    | UserMigrationForgotPasswordTriggerEvent;
+
+export type UserMigrationTriggerHandler = Handler<UserMigrationTriggerEvent>;

package/node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/verify-auth-challenge-response.d.ts

@@ -0,0 +1,22 @@
+import { Handler } from "../../handler";
+import { BaseTriggerEvent, StringMap } from "./_common";
+
+/**
+ * @see https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-lambda-verify-auth-challenge-response.html
+ */
+export interface VerifyAuthChallengeResponseTriggerEvent
+    extends BaseTriggerEvent<"VerifyAuthChallengeResponse_Authentication">
+{
+    request: {
+        userAttributes: StringMap;
+        privateChallengeParameters: StringMap;
+        challengeAnswer: string;
+        userNotFound?: boolean | undefined;
+        clientMetadata?: StringMap | undefined;
+    };
+    response: {
+        answerCorrect: boolean;
+    };
+}
+
+export type VerifyAuthChallengeResponseTriggerHandler = Handler<VerifyAuthChallengeResponseTriggerEvent>;

package/node_modules/@types/aws-lambda/trigger/connect-contact-flow.d.ts

@@ -0,0 +1,64 @@
+import { Callback, Handler } from "../handler";
+
+export type ConnectContactFlowHandler = Handler<ConnectContactFlowEvent, ConnectContactFlowResult>;
+export type ConnectContactFlowCallback = Callback<ConnectContactFlowResult>;
+
+// Connect
+// https://docs.aws.amazon.com/connect/latest/adminguide/connect-lambda-functions.html
+export interface ConnectContactFlowEvent {
+    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 };
+    };
+    Name: "ContactFlowEvent";
+}
+
+export type ConnectContactFlowChannel = "VOICE" | "CHAT";
+
+export type ConnectContactFlowInitiationMethod = "INBOUND" | "OUTBOUND" | "TRANSFER" | "CALLBACK" | "API";
+
+export interface ConnectContactFlowEndpoint {
+    Address: string;
+    Type: "TELEPHONE_NUMBER";
+}
+
+export interface ConnectContactFlowQueue {
+    ARN: string;
+    Name: string;
+}
+
+export interface ConnectContactFlowResult {
+    [key: string]: string | null;
+}
+
+export type CustomerAudio =
+    | null // If Media Streaming has never been started.
+    | StartedCustomerAudio // If Media Streaming has been started, but not stopped.
+    | (StartedCustomerAudio & StoppedCustomerAudio); // If Media Streaming has been started and stopped.
+
+export interface StartedCustomerAudio {
+    StartFragmentNumber: string;
+    StartTimestamp: string;
+    StreamARN: string;
+}
+
+export interface StoppedCustomerAudio {
+    StopFragmentNumber: string;
+    StopTimestamp: string;
+}

package/node_modules/@types/aws-lambda/trigger/dynamodb-stream.d.ts

@@ -0,0 +1,55 @@
+import { Handler } from "../handler";
+
+// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+export type DynamoDBStreamHandler = Handler<DynamoDBStreamEvent, DynamoDBBatchResponse | void>;
+
+// http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_streams_AttributeValue.html
+export interface AttributeValue {
+    B?: string | undefined;
+    BS?: string[] | undefined;
+    BOOL?: boolean | undefined;
+    L?: AttributeValue[] | undefined;
+    M?: { [id: string]: AttributeValue } | undefined;
+    N?: string | undefined;
+    NS?: string[] | undefined;
+    NULL?: boolean | undefined;
+    S?: string | undefined;
+    SS?: string[] | undefined;
+}
+
+// http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_streams_StreamRecord.html
+export interface StreamRecord {
+    ApproximateCreationDateTime?: number | undefined;
+    Keys?: { [key: string]: AttributeValue } | undefined;
+    NewImage?: { [key: string]: AttributeValue } | undefined;
+    OldImage?: { [key: string]: AttributeValue } | undefined;
+    SequenceNumber?: string | undefined;
+    SizeBytes?: number | undefined;
+    StreamViewType?: "KEYS_ONLY" | "NEW_IMAGE" | "OLD_IMAGE" | "NEW_AND_OLD_IMAGES" | undefined;
+}
+
+// http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_streams_Record.html
+export interface DynamoDBRecord {
+    awsRegion?: string | undefined;
+    dynamodb?: StreamRecord | undefined;
+    eventID?: string | undefined;
+    eventName?: "INSERT" | "MODIFY" | "REMOVE" | undefined;
+    eventSource?: string | undefined;
+    eventSourceARN?: string | undefined;
+    eventVersion?: string | undefined;
+    userIdentity?: any;
+}
+
+// http://docs.aws.amazon.com/lambda/latest/dg/eventsources.html#eventsources-ddb-update
+export interface DynamoDBStreamEvent {
+    Records: DynamoDBRecord[];
+}
+
+// https://docs.aws.amazon.com/lambda/latest/dg/with-ddb.html#services-ddb-batchfailurereporting
+export interface DynamoDBBatchResponse {
+    batchItemFailures: DynamoDBBatchItemFailure[];
+}
+
+export interface DynamoDBBatchItemFailure {
+    itemIdentifier: string;
+}

package/node_modules/@types/aws-lambda/trigger/eventbridge.d.ts

@@ -0,0 +1,19 @@
+import { Handler } from "../handler";
+
+export type EventBridgeHandler<TDetailType extends string, TDetail, TResult> = Handler<
+    EventBridgeEvent<TDetailType, TDetail>,
+    TResult
+>;
+
+export interface EventBridgeEvent<TDetailType extends string, TDetail> {
+    id: string;
+    version: string;
+    account: string;
+    time: string;
+    region: string;
+    resources: string[];
+    source: string;
+    "detail-type": TDetailType;
+    detail: TDetail;
+    "replay-name"?: string;
+}

package/node_modules/@types/aws-lambda/trigger/guard-duty-event-notification.d.ts

@@ -0,0 +1,36 @@
+import { EventBridgeEvent } from "./eventbridge";
+
+/**
+ * Guard Duty events
+ * https://docs.aws.amazon.com/guardduty/latest/ug/monitor-with-eventbridge-s3-malware-protection.html
+ */
+
+export interface GuardDutyScanResultNotificationEvent
+    extends
+        EventBridgeEvent<"GuardDuty Malware Protection Object Scan Result", GuardDutyScanResultNotificationEventDetail>
+{
+    source: "aws.guardduty";
+}
+
+export interface GuardDutyScanResultNotificationEventDetail {
+    schemaVersion: "1.0";
+    scanStatus: "COMPLETED" | "SKIPPED" | "FAILED";
+    resourceType: "S3_OBJECT";
+    s3ObjectDetails: {
+        bucketName: string;
+        objectKey: string;
+        eTag: string;
+        versionId: string;
+        s3Throttled: boolean;
+    };
+    scanResultDetails: {
+        scanResultStatus: "NO_THREATS_FOUND" | "THREAT_FOUND" | "UNSUPPORTED" | "ACCESS_DENIED" | "FAILED";
+        threats: GuardDutyThreatDetail[] | null;
+    };
+}
+
+export interface GuardDutyThreatDetail {
+    name: string;
+}
+
+export type GuardDutyNotificationEvent = GuardDutyScanResultNotificationEvent;

package/node_modules/@types/aws-lambda/trigger/iot-authorizer.d.ts

@@ -0,0 +1,48 @@
+import { Handler } from "../handler";
+import { PolicyDocument } from "./api-gateway-authorizer";
+
+export type IoTProtocolType = "http" | "mqtt" | "tls";
+
+export type IoTCustomAuthorizerHandler = Handler<IoTCustomAuthorizerEvent, IoTCustomAuthorizerResult>;
+
+export interface IoTProtocolDataTLS {
+    serverName: string; // The server name indication (SNI) host_name string.
+}
+
+export interface IoTProtocolDataHTTP {
+    headers: Record<string, string>;
+    queryString: string;
+}
+
+export interface IoTProtocolDataMQTT {
+    username?: string;
+    password?: string; // A base64-encoded string.
+    clientId: string; // Included in the event only when the device sends the value.
+}
+
+export interface IoTCustomAuthorizerEvent {
+    token?: string;
+    signatureVerified: boolean; // Indicates whether the device gateway has validated the signature.
+    protocols: IoTProtocolType[]; // Indicates which protocols to expect for the request.
+    protocolData: {
+        tls?: IoTProtocolDataTLS;
+        http?: IoTProtocolDataHTTP;
+        mqtt?: IoTProtocolDataMQTT;
+    };
+    connectionMetadata: {
+        id: string; // The connection ID. You can use this for logging.
+    };
+}
+
+/**
+ * IoT CustomAuthorizer AuthResponse.PolicyDocument.
+ * https://docs.aws.amazon.com/iot/latest/developerguide/config-custom-auth.html#custom-auth-lambda
+ * https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition
+ */
+export interface IoTCustomAuthorizerResult {
+    isAuthenticated: boolean; // A Boolean that determines whether client can connect.
+    principalId: string; // A string that identifies the connection in logs.
+    disconnectAfterInSeconds: number;
+    refreshAfterInSeconds: number;
+    policyDocuments: PolicyDocument[];
+}

package/node_modules/@types/aws-lambda/trigger/iot.d.ts

@@ -0,0 +1,28 @@
+import { Handler } from "../handler";
+
+export type IoTHandler = Handler<IoTEvent, void>;
+
+// IoT
+// https://docs.aws.amazon.com/lambda/latest/dg/services-iot.html
+// IoT payload is not restriced to JSON, but JSON is highly recommended. Types as string, number or array are possible to use.
+
+export type IoTEvent<T = never> = string | number | T;
+
+// PreProvisioningHook
+// https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html
+// When using AWS IoT fleet provisioning, you can set up a Lambda function to validate parameters passed from the device before allowing the device to be provisioned.
+export type IoTPreProvisioningHookHandler = Handler<IoTPreProvisioningHookEvent, IoTPreProvisioningHookResult>;
+
+export interface IoTPreProvisioningHookEvent {
+    claimCertificateId: string;
+    certificateId: string;
+    certificatePem: string;
+    templateArn: string;
+    clientId: string;
+    parameters: Record<string, string>;
+}
+
+export interface IoTPreProvisioningHookResult {
+    allowProvisioning: boolean;
+    parameterOverrides: Record<string, string>;
+}

package/node_modules/@types/aws-lambda/trigger/kinesis-firehose-transformation.d.ts

@@ -0,0 +1,51 @@
+import { Callback, Handler } from "../handler";
+
+export type FirehoseTransformationHandler = Handler<FirehoseTransformationEvent, FirehoseTransformationResult>;
+export type FirehoseTransformationCallback = Callback<FirehoseTransformationResult>;
+
+// Kinesis Data Firehose Event
+// https://docs.aws.amazon.com/lambda/latest/dg/eventsources.html#eventsources-kinesis-firehose
+// https://docs.aws.amazon.com/firehose/latest/dev/data-transformation.html
+// https://aws.amazon.com/blogs/compute/amazon-kinesis-firehose-data-transformation-with-aws-lambda/
+// Examples in the lambda blueprints
+export interface FirehoseTransformationEvent {
+    invocationId: string;
+    deliveryStreamArn: string;
+    sourceKinesisStreamArn?: string | undefined;
+    region: string;
+    records: FirehoseTransformationEventRecord[];
+}
+
+export interface FirehoseTransformationEventRecord {
+    recordId: string;
+    approximateArrivalTimestamp: number;
+    /** Base64 encoded */
+    data: string;
+    kinesisRecordMetadata?: FirehoseRecordMetadata | undefined;
+}
+
+export interface FirehoseRecordMetadata {
+    shardId: string;
+    partitionKey: string;
+    approximateArrivalTimestamp: number;
+    sequenceNumber: string;
+    subsequenceNumber: string;
+}
+
+export type FirehoseRecordTransformationStatus = "Ok" | "Dropped" | "ProcessingFailed";
+
+export interface FirehoseTransformationMetadata {
+    partitionKeys: { [name: string]: string };
+}
+
+export interface FirehoseTransformationResultRecord {
+    recordId: string;
+    result: FirehoseRecordTransformationStatus;
+    /** Encode in Base64 */
+    data?: string;
+    metadata?: FirehoseTransformationMetadata;
+}
+
+export interface FirehoseTransformationResult {
+    records: FirehoseTransformationResultRecord[];
+}

package/node_modules/@types/aws-lambda/trigger/kinesis-stream.d.ts

@@ -0,0 +1,56 @@
+import { Handler } from "../handler";
+
+// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+export type KinesisStreamHandler = Handler<KinesisStreamEvent, KinesisStreamBatchResponse | void>;
+
+export type KinesisStreamTumblingWindowHandler = Handler<
+    KinesisStreamTumblingWindowEvent,
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    KinesisStreamStateResponse | void
+>;
+
+// Kinesis Streams
+// https://docs.aws.amazon.com/lambda/latest/dg/eventsources.html#eventsources-kinesis-streams
+export interface KinesisStreamRecordPayload {
+    approximateArrivalTimestamp: number;
+    data: string;
+    kinesisSchemaVersion: string;
+    partitionKey: string;
+    sequenceNumber: string;
+}
+
+export interface KinesisStreamRecord {
+    awsRegion: string;
+    eventID: string;
+    eventName: string;
+    eventSource: string;
+    eventSourceARN: string;
+    eventVersion: string;
+    invokeIdentityArn: string;
+    kinesis: KinesisStreamRecordPayload;
+}
+
+export interface KinesisStreamEvent {
+    Records: KinesisStreamRecord[];
+}
+
+// https://docs.aws.amazon.com/lambda/latest/dg/with-kinesis.html#services-kinesis-windows
+export interface KinesisStreamTumblingWindowEvent extends KinesisStreamEvent {
+    window: { start: string; end: string };
+    state?: { [key: string]: any };
+    isFinalInvokeForWindow: boolean;
+    isWindowTerminatedEarly: boolean;
+}
+
+export interface KinesisStreamStateResponse extends Partial<KinesisStreamBatchResponse> {
+    state: { [key: string]: any };
+}
+
+// https://docs.aws.amazon.com/lambda/latest/dg/with-kinesis.html#services-kinesis-batchfailurereporting
+export interface KinesisStreamBatchResponse {
+    batchItemFailures: KinesisStreamBatchItemFailure[];
+}
+
+export interface KinesisStreamBatchItemFailure {
+    itemIdentifier: string;
+}

package/node_modules/@types/aws-lambda/trigger/lambda-function-url.d.ts

@@ -0,0 +1,45 @@
+import { Handler } from "../handler";
+import {
+    APIGatewayEventRequestContextIAMAuthorizer,
+    APIGatewayEventRequestContextV2WithAuthorizer,
+    APIGatewayProxyCallbackV2,
+    APIGatewayProxyEventV2,
+    APIGatewayProxyEventV2WithRequestContext,
+    APIGatewayProxyResultV2,
+} from "./api-gateway-proxy";
+
+/**
+ * Default Lambda Function URL event with no Authorizer
+ */
+export type LambdaFunctionURLEvent = APIGatewayProxyEventV2;
+
+/**
+ * Works with Lambda Function URL format which is currently the same as HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/lambda/latest/dg/urls-invocation.html#urls-payloads
+ */
+export type LambdaFunctionURLResult<T = never> = APIGatewayProxyResultV2<T>;
+
+/**
+ * Works with Lambda Function URL format which is currently the same as HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+export type LambdaFunctionURLCallback = APIGatewayProxyCallbackV2;
+
+/**
+ * Works with Lambda Function URL format which is currently the same as HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/lambda/latest/dg/urls-invocation.html#urls-payloads
+ */
+export type LambdaFunctionURLHandler<T = never> = Handler<LambdaFunctionURLEvent, LambdaFunctionURLResult<T>>;
+
+export type LambdaFunctionURLEventWithIAMAuthorizer = APIGatewayProxyEventV2WithRequestContext<
+    APIGatewayEventRequestContextV2WithAuthorizer<APIGatewayEventRequestContextIAMAuthorizer>
+>;
+
+/**
+ * Works with Lambda Function URL format which is currently the same as HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/lambda/latest/dg/urls-invocation.html#urls-payloads
+ */
+export type LambdaFunctionURLHandlerWithIAMAuthorizer<T = never> = Handler<
+    LambdaFunctionURLEventWithIAMAuthorizer,
+    LambdaFunctionURLResult<T>
+>;

package/node_modules/@types/aws-lambda/trigger/lex-v2.d.ts

@@ -0,0 +1,164 @@
+import { Callback, Handler } from "../handler";
+
+export type LexV2Handler = Handler<LexV2Event, LexV2Result>;
+export type LexV2Callback = Callback<LexV2Result>;
+
+// Lex V2
+// https://docs.aws.amazon.com/lexv2/latest/dg/lambda.html
+export interface LexV2Event {
+    messageVersion: string;
+    invocationSource: "DialogCodeHook" | "FulfillmentCodeHook";
+    inputMode: "DTMF" | "Speech" | "Text";
+    responseContentType: string;
+    sessionId: string;
+    inputTranscript: string;
+    bot: LexV2Bot;
+    interpretations: LexV2Interpretation[];
+    proposedNextState: {
+        dialogAction: LexV2DialogAction;
+        intent: LexV2Intent;
+    };
+    requestAttributes?: Record<string, string>;
+    sessionState: LexV2SessionState;
+    transcriptions: LexV2Transcription[];
+}
+
+export interface LexV2Bot {
+    id: string;
+    name: string;
+    aliasId: string;
+    aliasName: string;
+    localeId: string;
+    version: string; // 'DRAFT' | `${number}`
+}
+
+export interface LexV2Interpretation {
+    intent: LexV2Intent;
+    nluConfidence?: number;
+    sentimentResponse?: LexV2SentimentResponse;
+}
+
+export interface LexV2Intent {
+    confirmationState: "Confirmed" | "Denied" | "None";
+    name: string;
+    slots: LexV2Slots;
+    state: LexV2IntentState;
+    kendraResponse?: any;
+}
+
+export type LexV2IntentState =
+    | "Failed"
+    | "Fulfilled"
+    | "FulfillmentInProgress"
+    | "InProgress"
+    | "ReadyForFulfillment"
+    | "Waiting";
+
+export interface LexV2SentimentResponse {
+    sentiment: string;
+    sentimentScore: LexV2SentimentScore;
+}
+
+export interface LexV2SentimentScore {
+    mixed: number;
+    negative: number;
+    neutral: number;
+    positive: number;
+}
+
+export interface LexV2SessionState {
+    activeContexts?: LexV2ActiveContext[];
+    sessionAttributes?: Record<string, string>;
+    dialogAction?: LexV2DialogAction;
+    intent: LexV2Intent;
+    originatingRequestId: string;
+}
+
+export interface LexV2ActiveContext {
+    name: string;
+    contextAttributes: Record<string, string>;
+    timeToLive: {
+        timeToLiveInSeconds: number;
+        turnsToLive: number;
+    };
+}
+
+export type LevV2DialogActionWithoutSlot =
+    | { type: "Close" }
+    | { type: "ConfirmIntent" }
+    | { type: "Delegate" }
+    | { type: "ElicitIntent" };
+
+export type LexV2DialogAction =
+    | (LevV2DialogActionWithoutSlot & { slotToElicit?: never })
+    | { type: "ElicitSlot"; slotToElicit: string };
+
+export type LexV2ResultDialogAction =
+    | (LevV2DialogActionWithoutSlot & { slotToElicit?: never })
+    | { type: "ElicitSlot"; slotToElicit: string; slotElicitationStyle?: "Default" | "SpellByLetter" | "SpellByWord" };
+
+export interface LexV2Result {
+    sessionState: {
+        sessionAttributes?: Record<string, string>;
+        dialogAction: LexV2ResultDialogAction;
+        intent?: {
+            name?: string;
+            state: LexV2IntentState;
+            slots?: LexV2Slots;
+        };
+    };
+    messages?: LexV2Message[];
+}
+
+export type LexV2Message = LexV2ContentMessage | LexV2ImageResponseCardMessage;
+
+export interface LexV2ContentMessage {
+    contentType: "CustomPayload" | "PlainText" | "SSML";
+    content: string;
+}
+
+export interface LexV2ImageResponseCardMessage {
+    contentType: "ImageResponseCard";
+    imageResponseCard: LexV2ImageResponseCard;
+}
+
+export interface LexV2ImageResponseCard {
+    title: string;
+    subtitle?: string;
+    imageUrl?: string;
+    buttons?: LexV2ImageResponseCardButton[];
+}
+
+export interface LexV2ImageResponseCardButton {
+    text: string;
+    value: string;
+}
+
+export type LexV2Slot = LexV2ScalarSlotValue | LexV2ListSlotValue;
+export type LexV2Slots = Record<string, LexV2Slot | null>;
+
+export interface LexV2ScalarSlotValue {
+    shape: "Scalar";
+    value: LexV2SlotValue;
+}
+
+export interface LexV2ListSlotValue {
+    shape: "List";
+    value: LexV2SlotValue;
+    values: LexV2ScalarSlotValue[];
+}
+
+export interface LexV2SlotValue {
+    interpretedValue?: string;
+    originalValue: string;
+    resolvedValues: string[];
+}
+
+export interface LexV2Transcription {
+    transcription: string;
+    transcriptionConfidence: number;
+    resolvedContext: {
+        intent: string;
+    };
+    resolvedSlots: LexV2Slots;
+}