@aws-sdk/client-lambda 3.942.0 → 3.945.0

package/dist-types/ts3.4/commands/CheckpointDurableExecutionCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import {
+  LambdaClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LambdaClient";
+import {
+  CheckpointDurableExecutionRequest,
+  CheckpointDurableExecutionResponse,
+} from "../models/models_0";
+export { __MetadataBearer };
+export { $Command };
+export interface CheckpointDurableExecutionCommandInput
+  extends CheckpointDurableExecutionRequest {}
+export interface CheckpointDurableExecutionCommandOutput
+  extends CheckpointDurableExecutionResponse,
+    __MetadataBearer {}
+declare const CheckpointDurableExecutionCommand_base: {
+  new (
+    input: CheckpointDurableExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CheckpointDurableExecutionCommandInput,
+    CheckpointDurableExecutionCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  new (
+    input: CheckpointDurableExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    CheckpointDurableExecutionCommandInput,
+    CheckpointDurableExecutionCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class CheckpointDurableExecutionCommand extends CheckpointDurableExecutionCommand_base {
+  protected static __types: {
+    api: {
+      input: CheckpointDurableExecutionRequest;
+      output: CheckpointDurableExecutionResponse;
+    };
+    sdk: {
+      input: CheckpointDurableExecutionCommandInput;
+      output: CheckpointDurableExecutionCommandOutput;
+    };
+  };
+}

package/dist-types/ts3.4/commands/GetDurableExecutionCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import {
+  LambdaClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LambdaClient";
+import {
+  GetDurableExecutionRequest,
+  GetDurableExecutionResponse,
+} from "../models/models_0";
+export { __MetadataBearer };
+export { $Command };
+export interface GetDurableExecutionCommandInput
+  extends GetDurableExecutionRequest {}
+export interface GetDurableExecutionCommandOutput
+  extends GetDurableExecutionResponse,
+    __MetadataBearer {}
+declare const GetDurableExecutionCommand_base: {
+  new (
+    input: GetDurableExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    GetDurableExecutionCommandInput,
+    GetDurableExecutionCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  new (
+    input: GetDurableExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    GetDurableExecutionCommandInput,
+    GetDurableExecutionCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class GetDurableExecutionCommand extends GetDurableExecutionCommand_base {
+  protected static __types: {
+    api: {
+      input: GetDurableExecutionRequest;
+      output: GetDurableExecutionResponse;
+    };
+    sdk: {
+      input: GetDurableExecutionCommandInput;
+      output: GetDurableExecutionCommandOutput;
+    };
+  };
+}

package/dist-types/ts3.4/commands/GetDurableExecutionHistoryCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import {
+  LambdaClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LambdaClient";
+import {
+  GetDurableExecutionHistoryRequest,
+  GetDurableExecutionHistoryResponse,
+} from "../models/models_0";
+export { __MetadataBearer };
+export { $Command };
+export interface GetDurableExecutionHistoryCommandInput
+  extends GetDurableExecutionHistoryRequest {}
+export interface GetDurableExecutionHistoryCommandOutput
+  extends GetDurableExecutionHistoryResponse,
+    __MetadataBearer {}
+declare const GetDurableExecutionHistoryCommand_base: {
+  new (
+    input: GetDurableExecutionHistoryCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    GetDurableExecutionHistoryCommandInput,
+    GetDurableExecutionHistoryCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  new (
+    input: GetDurableExecutionHistoryCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    GetDurableExecutionHistoryCommandInput,
+    GetDurableExecutionHistoryCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class GetDurableExecutionHistoryCommand extends GetDurableExecutionHistoryCommand_base {
+  protected static __types: {
+    api: {
+      input: GetDurableExecutionHistoryRequest;
+      output: GetDurableExecutionHistoryResponse;
+    };
+    sdk: {
+      input: GetDurableExecutionHistoryCommandInput;
+      output: GetDurableExecutionHistoryCommandOutput;
+    };
+  };
+}

package/dist-types/ts3.4/commands/GetDurableExecutionStateCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import {
+  LambdaClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LambdaClient";
+import {
+  GetDurableExecutionStateRequest,
+  GetDurableExecutionStateResponse,
+} from "../models/models_0";
+export { __MetadataBearer };
+export { $Command };
+export interface GetDurableExecutionStateCommandInput
+  extends GetDurableExecutionStateRequest {}
+export interface GetDurableExecutionStateCommandOutput
+  extends GetDurableExecutionStateResponse,
+    __MetadataBearer {}
+declare const GetDurableExecutionStateCommand_base: {
+  new (
+    input: GetDurableExecutionStateCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    GetDurableExecutionStateCommandInput,
+    GetDurableExecutionStateCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  new (
+    input: GetDurableExecutionStateCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    GetDurableExecutionStateCommandInput,
+    GetDurableExecutionStateCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class GetDurableExecutionStateCommand extends GetDurableExecutionStateCommand_base {
+  protected static __types: {
+    api: {
+      input: GetDurableExecutionStateRequest;
+      output: GetDurableExecutionStateResponse;
+    };
+    sdk: {
+      input: GetDurableExecutionStateCommandInput;
+      output: GetDurableExecutionStateCommandOutput;
+    };
+  };
+}

package/dist-types/ts3.4/commands/ListDurableExecutionsByFunctionCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import {
+  LambdaClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LambdaClient";
+import {
+  ListDurableExecutionsByFunctionRequest,
+  ListDurableExecutionsByFunctionResponse,
+} from "../models/models_0";
+export { __MetadataBearer };
+export { $Command };
+export interface ListDurableExecutionsByFunctionCommandInput
+  extends ListDurableExecutionsByFunctionRequest {}
+export interface ListDurableExecutionsByFunctionCommandOutput
+  extends ListDurableExecutionsByFunctionResponse,
+    __MetadataBearer {}
+declare const ListDurableExecutionsByFunctionCommand_base: {
+  new (
+    input: ListDurableExecutionsByFunctionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListDurableExecutionsByFunctionCommandInput,
+    ListDurableExecutionsByFunctionCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  new (
+    input: ListDurableExecutionsByFunctionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListDurableExecutionsByFunctionCommandInput,
+    ListDurableExecutionsByFunctionCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListDurableExecutionsByFunctionCommand extends ListDurableExecutionsByFunctionCommand_base {
+  protected static __types: {
+    api: {
+      input: ListDurableExecutionsByFunctionRequest;
+      output: ListDurableExecutionsByFunctionResponse;
+    };
+    sdk: {
+      input: ListDurableExecutionsByFunctionCommandInput;
+      output: ListDurableExecutionsByFunctionCommandOutput;
+    };
+  };
+}

package/dist-types/ts3.4/commands/SendDurableExecutionCallbackFailureCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import {
+  LambdaClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LambdaClient";
+import {
+  SendDurableExecutionCallbackFailureRequest,
+  SendDurableExecutionCallbackFailureResponse,
+} from "../models/models_0";
+export { __MetadataBearer };
+export { $Command };
+export interface SendDurableExecutionCallbackFailureCommandInput
+  extends SendDurableExecutionCallbackFailureRequest {}
+export interface SendDurableExecutionCallbackFailureCommandOutput
+  extends SendDurableExecutionCallbackFailureResponse,
+    __MetadataBearer {}
+declare const SendDurableExecutionCallbackFailureCommand_base: {
+  new (
+    input: SendDurableExecutionCallbackFailureCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    SendDurableExecutionCallbackFailureCommandInput,
+    SendDurableExecutionCallbackFailureCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  new (
+    input: SendDurableExecutionCallbackFailureCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    SendDurableExecutionCallbackFailureCommandInput,
+    SendDurableExecutionCallbackFailureCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class SendDurableExecutionCallbackFailureCommand extends SendDurableExecutionCallbackFailureCommand_base {
+  protected static __types: {
+    api: {
+      input: SendDurableExecutionCallbackFailureRequest;
+      output: {};
+    };
+    sdk: {
+      input: SendDurableExecutionCallbackFailureCommandInput;
+      output: SendDurableExecutionCallbackFailureCommandOutput;
+    };
+  };
+}

package/dist-types/ts3.4/commands/SendDurableExecutionCallbackHeartbeatCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import {
+  LambdaClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LambdaClient";
+import {
+  SendDurableExecutionCallbackHeartbeatRequest,
+  SendDurableExecutionCallbackHeartbeatResponse,
+} from "../models/models_0";
+export { __MetadataBearer };
+export { $Command };
+export interface SendDurableExecutionCallbackHeartbeatCommandInput
+  extends SendDurableExecutionCallbackHeartbeatRequest {}
+export interface SendDurableExecutionCallbackHeartbeatCommandOutput
+  extends SendDurableExecutionCallbackHeartbeatResponse,
+    __MetadataBearer {}
+declare const SendDurableExecutionCallbackHeartbeatCommand_base: {
+  new (
+    input: SendDurableExecutionCallbackHeartbeatCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    SendDurableExecutionCallbackHeartbeatCommandInput,
+    SendDurableExecutionCallbackHeartbeatCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  new (
+    input: SendDurableExecutionCallbackHeartbeatCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    SendDurableExecutionCallbackHeartbeatCommandInput,
+    SendDurableExecutionCallbackHeartbeatCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class SendDurableExecutionCallbackHeartbeatCommand extends SendDurableExecutionCallbackHeartbeatCommand_base {
+  protected static __types: {
+    api: {
+      input: SendDurableExecutionCallbackHeartbeatRequest;
+      output: {};
+    };
+    sdk: {
+      input: SendDurableExecutionCallbackHeartbeatCommandInput;
+      output: SendDurableExecutionCallbackHeartbeatCommandOutput;
+    };
+  };
+}

package/dist-types/ts3.4/commands/SendDurableExecutionCallbackSuccessCommand.d.ts

@@ -0,0 +1,60 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import {
+  BlobPayloadInputTypes,
+  MetadataBearer as __MetadataBearer,
+} from "@smithy/types";
+import {
+  LambdaClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LambdaClient";
+import {
+  SendDurableExecutionCallbackSuccessRequest,
+  SendDurableExecutionCallbackSuccessResponse,
+} from "../models/models_0";
+export { __MetadataBearer };
+export { $Command };
+export type SendDurableExecutionCallbackSuccessCommandInputType = Pick<
+  SendDurableExecutionCallbackSuccessRequest,
+  Exclude<keyof SendDurableExecutionCallbackSuccessRequest, "Result">
+> & {
+  Result?: BlobPayloadInputTypes;
+};
+export interface SendDurableExecutionCallbackSuccessCommandInput
+  extends SendDurableExecutionCallbackSuccessCommandInputType {}
+export interface SendDurableExecutionCallbackSuccessCommandOutput
+  extends SendDurableExecutionCallbackSuccessResponse,
+    __MetadataBearer {}
+declare const SendDurableExecutionCallbackSuccessCommand_base: {
+  new (
+    input: SendDurableExecutionCallbackSuccessCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    SendDurableExecutionCallbackSuccessCommandInput,
+    SendDurableExecutionCallbackSuccessCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  new (
+    input: SendDurableExecutionCallbackSuccessCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    SendDurableExecutionCallbackSuccessCommandInput,
+    SendDurableExecutionCallbackSuccessCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class SendDurableExecutionCallbackSuccessCommand extends SendDurableExecutionCallbackSuccessCommand_base {
+  protected static __types: {
+    api: {
+      input: SendDurableExecutionCallbackSuccessRequest;
+      output: {};
+    };
+    sdk: {
+      input: SendDurableExecutionCallbackSuccessCommandInput;
+      output: SendDurableExecutionCallbackSuccessCommandOutput;
+    };
+  };
+}

package/dist-types/ts3.4/commands/StopDurableExecutionCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import {
+  LambdaClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LambdaClient";
+import {
+  StopDurableExecutionRequest,
+  StopDurableExecutionResponse,
+} from "../models/models_0";
+export { __MetadataBearer };
+export { $Command };
+export interface StopDurableExecutionCommandInput
+  extends StopDurableExecutionRequest {}
+export interface StopDurableExecutionCommandOutput
+  extends StopDurableExecutionResponse,
+    __MetadataBearer {}
+declare const StopDurableExecutionCommand_base: {
+  new (
+    input: StopDurableExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    StopDurableExecutionCommandInput,
+    StopDurableExecutionCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  new (
+    input: StopDurableExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    StopDurableExecutionCommandInput,
+    StopDurableExecutionCommandOutput,
+    LambdaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StopDurableExecutionCommand extends StopDurableExecutionCommand_base {
+  protected static __types: {
+    api: {
+      input: StopDurableExecutionRequest;
+      output: StopDurableExecutionResponse;
+    };
+    sdk: {
+      input: StopDurableExecutionCommandInput;
+      output: StopDurableExecutionCommandOutput;
+    };
+  };
+}

package/dist-types/ts3.4/commands/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./AddLayerVersionPermissionCommand";
 export * from "./AddPermissionCommand";
+export * from "./CheckpointDurableExecutionCommand";
 export * from "./CreateAliasCommand";
 export * from "./CreateCapacityProviderCommand";
 export * from "./CreateCodeSigningConfigCommand";
@@ -21,6 +22,9 @@ export * from "./GetAccountSettingsCommand";
 export * from "./GetAliasCommand";
 export * from "./GetCapacityProviderCommand";
 export * from "./GetCodeSigningConfigCommand";
+export * from "./GetDurableExecutionCommand";
+export * from "./GetDurableExecutionHistoryCommand";
+export * from "./GetDurableExecutionStateCommand";
 export * from "./GetEventSourceMappingCommand";
 export * from "./GetFunctionCodeSigningConfigCommand";
 export * from "./GetFunctionCommand";
@@ -42,6 +46,7 @@ export * from "./InvokeWithResponseStreamCommand";
 export * from "./ListAliasesCommand";
 export * from "./ListCapacityProvidersCommand";
 export * from "./ListCodeSigningConfigsCommand";
+export * from "./ListDurableExecutionsByFunctionCommand";
 export * from "./ListEventSourceMappingsCommand";
 export * from "./ListFunctionEventInvokeConfigsCommand";
 export * from "./ListFunctionUrlConfigsCommand";
@@ -64,6 +69,10 @@ export * from "./PutProvisionedConcurrencyConfigCommand";
 export * from "./PutRuntimeManagementConfigCommand";
 export * from "./RemoveLayerVersionPermissionCommand";
 export * from "./RemovePermissionCommand";
+export * from "./SendDurableExecutionCallbackFailureCommand";
+export * from "./SendDurableExecutionCallbackHeartbeatCommand";
+export * from "./SendDurableExecutionCallbackSuccessCommand";
+export * from "./StopDurableExecutionCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateAliasCommand";

package/dist-types/ts3.4/models/enums.d.ts

@@ -78,6 +78,36 @@ export declare const State: {
   readonly Pending: "Pending";
 };
 export type State = (typeof State)[keyof typeof State];
+export declare const OperationAction: {
+  readonly CANCEL: "CANCEL";
+  readonly FAIL: "FAIL";
+  readonly RETRY: "RETRY";
+  readonly START: "START";
+  readonly SUCCEED: "SUCCEED";
+};
+export type OperationAction =
+  (typeof OperationAction)[keyof typeof OperationAction];
+export declare const OperationType: {
+  readonly CALLBACK: "CALLBACK";
+  readonly CHAINED_INVOKE: "CHAINED_INVOKE";
+  readonly CONTEXT: "CONTEXT";
+  readonly EXECUTION: "EXECUTION";
+  readonly STEP: "STEP";
+  readonly WAIT: "WAIT";
+};
+export type OperationType = (typeof OperationType)[keyof typeof OperationType];
+export declare const OperationStatus: {
+  readonly CANCELLED: "CANCELLED";
+  readonly FAILED: "FAILED";
+  readonly PENDING: "PENDING";
+  readonly READY: "READY";
+  readonly STARTED: "STARTED";
+  readonly STOPPED: "STOPPED";
+  readonly SUCCEEDED: "SUCCEEDED";
+  readonly TIMED_OUT: "TIMED_OUT";
+};
+export type OperationStatus =
+  (typeof OperationStatus)[keyof typeof OperationStatus];
 export declare const CodeSigningPolicy: {
   readonly Enforce: "Enforce";
   readonly Warn: "Warn";
@@ -217,6 +247,7 @@ export type LastUpdateStatus =
 export declare const LastUpdateStatusReasonCode: {
   readonly CapacityProviderScalingLimitExceeded: "CapacityProviderScalingLimitExceeded";
   readonly DisabledKMSKey: "DisabledKMSKey";
+  readonly DisallowedByVpcEncryptionControl: "DisallowedByVpcEncryptionControl";
   readonly EC2RequestLimitExceeded: "EC2RequestLimitExceeded";
   readonly EFSIOError: "EFSIOError";
   readonly EFSMountConnectivityError: "EFSMountConnectivityError";
@@ -261,6 +292,8 @@ export declare const StateReasonCode: {
   readonly CapacityProviderScalingLimitExceeded: "CapacityProviderScalingLimitExceeded";
   readonly Creating: "Creating";
   readonly DisabledKMSKey: "DisabledKMSKey";
+  readonly DisallowedByVpcEncryptionControl: "DisallowedByVpcEncryptionControl";
+  readonly DrainingDurableExecutions: "DrainingDurableExecutions";
   readonly EC2RequestLimitExceeded: "EC2RequestLimitExceeded";
   readonly EFSIOError: "EFSIOError";
   readonly EFSMountConnectivityError: "EFSMountConnectivityError";
@@ -344,3 +377,39 @@ export declare const ProvisionedConcurrencyStatusEnum: {
 };
 export type ProvisionedConcurrencyStatusEnum =
   (typeof ProvisionedConcurrencyStatusEnum)[keyof typeof ProvisionedConcurrencyStatusEnum];
+export declare const ExecutionStatus: {
+  readonly FAILED: "FAILED";
+  readonly RUNNING: "RUNNING";
+  readonly STOPPED: "STOPPED";
+  readonly SUCCEEDED: "SUCCEEDED";
+  readonly TIMED_OUT: "TIMED_OUT";
+};
+export type ExecutionStatus =
+  (typeof ExecutionStatus)[keyof typeof ExecutionStatus];
+export declare const EventType: {
+  readonly CallbackFailed: "CallbackFailed";
+  readonly CallbackStarted: "CallbackStarted";
+  readonly CallbackSucceeded: "CallbackSucceeded";
+  readonly CallbackTimedOut: "CallbackTimedOut";
+  readonly ChainedInvokeFailed: "ChainedInvokeFailed";
+  readonly ChainedInvokeStarted: "ChainedInvokeStarted";
+  readonly ChainedInvokeStopped: "ChainedInvokeStopped";
+  readonly ChainedInvokeSucceeded: "ChainedInvokeSucceeded";
+  readonly ChainedInvokeTimedOut: "ChainedInvokeTimedOut";
+  readonly ContextFailed: "ContextFailed";
+  readonly ContextStarted: "ContextStarted";
+  readonly ContextSucceeded: "ContextSucceeded";
+  readonly ExecutionFailed: "ExecutionFailed";
+  readonly ExecutionStarted: "ExecutionStarted";
+  readonly ExecutionStopped: "ExecutionStopped";
+  readonly ExecutionSucceeded: "ExecutionSucceeded";
+  readonly ExecutionTimedOut: "ExecutionTimedOut";
+  readonly InvocationCompleted: "InvocationCompleted";
+  readonly StepFailed: "StepFailed";
+  readonly StepStarted: "StepStarted";
+  readonly StepSucceeded: "StepSucceeded";
+  readonly WaitCancelled: "WaitCancelled";
+  readonly WaitStarted: "WaitStarted";
+  readonly WaitSucceeded: "WaitSucceeded";
+};
+export type EventType = (typeof EventType)[keyof typeof EventType];

package/dist-types/ts3.4/models/errors.d.ts

@@ -131,6 +131,18 @@ export declare class InvalidCodeSignatureException extends __BaseException {
     opts: __ExceptionOptionType<InvalidCodeSignatureException, __BaseException>
   );
 }
+export declare class DurableExecutionAlreadyStartedException extends __BaseException {
+  readonly name: "DurableExecutionAlreadyStartedException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<
+      DurableExecutionAlreadyStartedException,
+      __BaseException
+    >
+  );
+}
 export declare class EC2AccessDeniedException extends __BaseException {
   readonly name: "EC2AccessDeniedException";
   readonly $fault: "server";
@@ -386,3 +398,12 @@ export declare class ProvisionedConcurrencyConfigNotFoundException extends __Bas
     >
   );
 }
+export declare class CallbackTimeoutException extends __BaseException {
+  readonly name: "CallbackTimeoutException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<CallbackTimeoutException, __BaseException>
+  );
+}