@aws-sdk/client-lambda 3.934.0 → 3.935.0

package/dist-types/schemas/schemas_0.d.ts

@@ -193,6 +193,7 @@ export declare var SourceAccessConfiguration: StaticStructureSchema;
 export declare var SubnetIPAddressLimitReachedException: StaticErrorSchema;
 export declare var TagResourceRequest: StaticStructureSchema;
 export declare var TagsError: StaticStructureSchema;
+export declare var TenancyConfig: StaticStructureSchema;
 export declare var TooManyRequestsException: StaticErrorSchema;
 export declare var TracingConfig: StaticStructureSchema;
 export declare var TracingConfigResponse: StaticStructureSchema;

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

@@ -6,5 +6,7 @@ export { LambdaExtensionConfiguration } from "./extensionConfiguration";
 export * from "./commands";
 export * from "./pagination";
 export * from "./waiters";
-export * from "./models";
+export * from "./models/enums";
+export * from "./models/errors";
+export * from "./models/models_0";
 export { LambdaServiceException } from "./models/LambdaServiceException";

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

@@ -0,0 +1,294 @@
+export declare const ThrottleReason: {
+  readonly CallerRateLimitExceeded: "CallerRateLimitExceeded";
+  readonly ConcurrentInvocationLimitExceeded: "ConcurrentInvocationLimitExceeded";
+  readonly ConcurrentSnapshotCreateLimitExceeded: "ConcurrentSnapshotCreateLimitExceeded";
+  readonly FunctionInvocationRateLimitExceeded: "FunctionInvocationRateLimitExceeded";
+  readonly ReservedFunctionConcurrentInvocationLimitExceeded: "ReservedFunctionConcurrentInvocationLimitExceeded";
+  readonly ReservedFunctionInvocationRateLimitExceeded: "ReservedFunctionInvocationRateLimitExceeded";
+};
+export type ThrottleReason =
+  (typeof ThrottleReason)[keyof typeof ThrottleReason];
+export declare const FunctionUrlAuthType: {
+  readonly AWS_IAM: "AWS_IAM";
+  readonly NONE: "NONE";
+};
+export type FunctionUrlAuthType =
+  (typeof FunctionUrlAuthType)[keyof typeof FunctionUrlAuthType];
+export declare const KafkaSchemaRegistryAuthType: {
+  readonly BASIC_AUTH: "BASIC_AUTH";
+  readonly CLIENT_CERTIFICATE_TLS_AUTH: "CLIENT_CERTIFICATE_TLS_AUTH";
+  readonly SERVER_ROOT_CA_CERTIFICATE: "SERVER_ROOT_CA_CERTIFICATE";
+};
+export type KafkaSchemaRegistryAuthType =
+  (typeof KafkaSchemaRegistryAuthType)[keyof typeof KafkaSchemaRegistryAuthType];
+export declare const SchemaRegistryEventRecordFormat: {
+  readonly JSON: "JSON";
+  readonly SOURCE: "SOURCE";
+};
+export type SchemaRegistryEventRecordFormat =
+  (typeof SchemaRegistryEventRecordFormat)[keyof typeof SchemaRegistryEventRecordFormat];
+export declare const KafkaSchemaValidationAttribute: {
+  readonly KEY: "KEY";
+  readonly VALUE: "VALUE";
+};
+export type KafkaSchemaValidationAttribute =
+  (typeof KafkaSchemaValidationAttribute)[keyof typeof KafkaSchemaValidationAttribute];
+export declare const ApplicationLogLevel: {
+  readonly Debug: "DEBUG";
+  readonly Error: "ERROR";
+  readonly Fatal: "FATAL";
+  readonly Info: "INFO";
+  readonly Trace: "TRACE";
+  readonly Warn: "WARN";
+};
+export type ApplicationLogLevel =
+  (typeof ApplicationLogLevel)[keyof typeof ApplicationLogLevel];
+export declare const Architecture: {
+  readonly arm64: "arm64";
+  readonly x86_64: "x86_64";
+};
+export type Architecture = (typeof Architecture)[keyof typeof Architecture];
+export declare const CodeSigningPolicy: {
+  readonly Enforce: "Enforce";
+  readonly Warn: "Warn";
+};
+export type CodeSigningPolicy =
+  (typeof CodeSigningPolicy)[keyof typeof CodeSigningPolicy];
+export declare const FullDocument: {
+  readonly Default: "Default";
+  readonly UpdateLookup: "UpdateLookup";
+};
+export type FullDocument = (typeof FullDocument)[keyof typeof FullDocument];
+export declare const FunctionResponseType: {
+  readonly ReportBatchItemFailures: "ReportBatchItemFailures";
+};
+export type FunctionResponseType =
+  (typeof FunctionResponseType)[keyof typeof FunctionResponseType];
+export declare const EventSourceMappingMetric: {
+  readonly EventCount: "EventCount";
+};
+export type EventSourceMappingMetric =
+  (typeof EventSourceMappingMetric)[keyof typeof EventSourceMappingMetric];
+export declare const EndPointType: {
+  readonly KAFKA_BOOTSTRAP_SERVERS: "KAFKA_BOOTSTRAP_SERVERS";
+};
+export type EndPointType = (typeof EndPointType)[keyof typeof EndPointType];
+export declare const SourceAccessType: {
+  readonly BASIC_AUTH: "BASIC_AUTH";
+  readonly CLIENT_CERTIFICATE_TLS_AUTH: "CLIENT_CERTIFICATE_TLS_AUTH";
+  readonly SASL_SCRAM_256_AUTH: "SASL_SCRAM_256_AUTH";
+  readonly SASL_SCRAM_512_AUTH: "SASL_SCRAM_512_AUTH";
+  readonly SERVER_ROOT_CA_CERTIFICATE: "SERVER_ROOT_CA_CERTIFICATE";
+  readonly VIRTUAL_HOST: "VIRTUAL_HOST";
+  readonly VPC_SECURITY_GROUP: "VPC_SECURITY_GROUP";
+  readonly VPC_SUBNET: "VPC_SUBNET";
+};
+export type SourceAccessType =
+  (typeof SourceAccessType)[keyof typeof SourceAccessType];
+export declare const EventSourcePosition: {
+  readonly AT_TIMESTAMP: "AT_TIMESTAMP";
+  readonly LATEST: "LATEST";
+  readonly TRIM_HORIZON: "TRIM_HORIZON";
+};
+export type EventSourcePosition =
+  (typeof EventSourcePosition)[keyof typeof EventSourcePosition];
+export declare const LogFormat: {
+  readonly Json: "JSON";
+  readonly Text: "Text";
+};
+export type LogFormat = (typeof LogFormat)[keyof typeof LogFormat];
+export declare const SystemLogLevel: {
+  readonly Debug: "DEBUG";
+  readonly Info: "INFO";
+  readonly Warn: "WARN";
+};
+export type SystemLogLevel =
+  (typeof SystemLogLevel)[keyof typeof SystemLogLevel];
+export declare const PackageType: {
+  readonly Image: "Image";
+  readonly Zip: "Zip";
+};
+export type PackageType = (typeof PackageType)[keyof typeof PackageType];
+export declare const Runtime: {
+  readonly dotnet6: "dotnet6";
+  readonly dotnet8: "dotnet8";
+  readonly dotnetcore10: "dotnetcore1.0";
+  readonly dotnetcore20: "dotnetcore2.0";
+  readonly dotnetcore21: "dotnetcore2.1";
+  readonly dotnetcore31: "dotnetcore3.1";
+  readonly go1x: "go1.x";
+  readonly java11: "java11";
+  readonly java17: "java17";
+  readonly java21: "java21";
+  readonly java25: "java25";
+  readonly java8: "java8";
+  readonly java8al2: "java8.al2";
+  readonly nodejs: "nodejs";
+  readonly nodejs10x: "nodejs10.x";
+  readonly nodejs12x: "nodejs12.x";
+  readonly nodejs14x: "nodejs14.x";
+  readonly nodejs16x: "nodejs16.x";
+  readonly nodejs18x: "nodejs18.x";
+  readonly nodejs20x: "nodejs20.x";
+  readonly nodejs22x: "nodejs22.x";
+  readonly nodejs24x: "nodejs24.x";
+  readonly nodejs43: "nodejs4.3";
+  readonly nodejs43edge: "nodejs4.3-edge";
+  readonly nodejs610: "nodejs6.10";
+  readonly nodejs810: "nodejs8.10";
+  readonly provided: "provided";
+  readonly providedal2: "provided.al2";
+  readonly providedal2023: "provided.al2023";
+  readonly python27: "python2.7";
+  readonly python310: "python3.10";
+  readonly python311: "python3.11";
+  readonly python312: "python3.12";
+  readonly python313: "python3.13";
+  readonly python314: "python3.14";
+  readonly python36: "python3.6";
+  readonly python37: "python3.7";
+  readonly python38: "python3.8";
+  readonly python39: "python3.9";
+  readonly ruby25: "ruby2.5";
+  readonly ruby27: "ruby2.7";
+  readonly ruby32: "ruby3.2";
+  readonly ruby33: "ruby3.3";
+  readonly ruby34: "ruby3.4";
+};
+export type Runtime = (typeof Runtime)[keyof typeof Runtime];
+export declare const SnapStartApplyOn: {
+  readonly None: "None";
+  readonly PublishedVersions: "PublishedVersions";
+};
+export type SnapStartApplyOn =
+  (typeof SnapStartApplyOn)[keyof typeof SnapStartApplyOn];
+export declare const TenantIsolationMode: {
+  readonly PER_TENANT: "PER_TENANT";
+};
+export type TenantIsolationMode =
+  (typeof TenantIsolationMode)[keyof typeof TenantIsolationMode];
+export declare const TracingMode: {
+  readonly Active: "Active";
+  readonly PassThrough: "PassThrough";
+};
+export type TracingMode = (typeof TracingMode)[keyof typeof TracingMode];
+export declare const LastUpdateStatus: {
+  readonly Failed: "Failed";
+  readonly InProgress: "InProgress";
+  readonly Successful: "Successful";
+};
+export type LastUpdateStatus =
+  (typeof LastUpdateStatus)[keyof typeof LastUpdateStatus];
+export declare const LastUpdateStatusReasonCode: {
+  readonly DisabledKMSKey: "DisabledKMSKey";
+  readonly EFSIOError: "EFSIOError";
+  readonly EFSMountConnectivityError: "EFSMountConnectivityError";
+  readonly EFSMountFailure: "EFSMountFailure";
+  readonly EFSMountTimeout: "EFSMountTimeout";
+  readonly EniLimitExceeded: "EniLimitExceeded";
+  readonly FunctionError: "FunctionError";
+  readonly ImageAccessDenied: "ImageAccessDenied";
+  readonly ImageDeleted: "ImageDeleted";
+  readonly InsufficientRolePermissions: "InsufficientRolePermissions";
+  readonly InternalError: "InternalError";
+  readonly InvalidConfiguration: "InvalidConfiguration";
+  readonly InvalidImage: "InvalidImage";
+  readonly InvalidRuntime: "InvalidRuntime";
+  readonly InvalidSecurityGroup: "InvalidSecurityGroup";
+  readonly InvalidStateKMSKey: "InvalidStateKMSKey";
+  readonly InvalidSubnet: "InvalidSubnet";
+  readonly InvalidZipFileException: "InvalidZipFileException";
+  readonly KMSKeyAccessDenied: "KMSKeyAccessDenied";
+  readonly KMSKeyNotFound: "KMSKeyNotFound";
+  readonly SubnetOutOfIPAddresses: "SubnetOutOfIPAddresses";
+};
+export type LastUpdateStatusReasonCode =
+  (typeof LastUpdateStatusReasonCode)[keyof typeof LastUpdateStatusReasonCode];
+export declare const SnapStartOptimizationStatus: {
+  readonly Off: "Off";
+  readonly On: "On";
+};
+export type SnapStartOptimizationStatus =
+  (typeof SnapStartOptimizationStatus)[keyof typeof SnapStartOptimizationStatus];
+export declare const State: {
+  readonly Active: "Active";
+  readonly Failed: "Failed";
+  readonly Inactive: "Inactive";
+  readonly Pending: "Pending";
+};
+export type State = (typeof State)[keyof typeof State];
+export declare const StateReasonCode: {
+  readonly Creating: "Creating";
+  readonly DisabledKMSKey: "DisabledKMSKey";
+  readonly EFSIOError: "EFSIOError";
+  readonly EFSMountConnectivityError: "EFSMountConnectivityError";
+  readonly EFSMountFailure: "EFSMountFailure";
+  readonly EFSMountTimeout: "EFSMountTimeout";
+  readonly EniLimitExceeded: "EniLimitExceeded";
+  readonly FunctionError: "FunctionError";
+  readonly Idle: "Idle";
+  readonly ImageAccessDenied: "ImageAccessDenied";
+  readonly ImageDeleted: "ImageDeleted";
+  readonly InsufficientRolePermissions: "InsufficientRolePermissions";
+  readonly InternalError: "InternalError";
+  readonly InvalidConfiguration: "InvalidConfiguration";
+  readonly InvalidImage: "InvalidImage";
+  readonly InvalidRuntime: "InvalidRuntime";
+  readonly InvalidSecurityGroup: "InvalidSecurityGroup";
+  readonly InvalidStateKMSKey: "InvalidStateKMSKey";
+  readonly InvalidSubnet: "InvalidSubnet";
+  readonly InvalidZipFileException: "InvalidZipFileException";
+  readonly KMSKeyAccessDenied: "KMSKeyAccessDenied";
+  readonly KMSKeyNotFound: "KMSKeyNotFound";
+  readonly Restoring: "Restoring";
+  readonly SubnetOutOfIPAddresses: "SubnetOutOfIPAddresses";
+};
+export type StateReasonCode =
+  (typeof StateReasonCode)[keyof typeof StateReasonCode];
+export declare const InvokeMode: {
+  readonly BUFFERED: "BUFFERED";
+  readonly RESPONSE_STREAM: "RESPONSE_STREAM";
+};
+export type InvokeMode = (typeof InvokeMode)[keyof typeof InvokeMode];
+export declare const RecursiveLoop: {
+  readonly Allow: "Allow";
+  readonly Terminate: "Terminate";
+};
+export type RecursiveLoop = (typeof RecursiveLoop)[keyof typeof RecursiveLoop];
+export declare const UpdateRuntimeOn: {
+  readonly Auto: "Auto";
+  readonly FunctionUpdate: "FunctionUpdate";
+  readonly Manual: "Manual";
+};
+export type UpdateRuntimeOn =
+  (typeof UpdateRuntimeOn)[keyof typeof UpdateRuntimeOn];
+export declare const InvocationType: {
+  readonly DryRun: "DryRun";
+  readonly Event: "Event";
+  readonly RequestResponse: "RequestResponse";
+};
+export type InvocationType =
+  (typeof InvocationType)[keyof typeof InvocationType];
+export declare const LogType: {
+  readonly None: "None";
+  readonly Tail: "Tail";
+};
+export type LogType = (typeof LogType)[keyof typeof LogType];
+export declare const ResponseStreamingInvocationType: {
+  readonly DryRun: "DryRun";
+  readonly RequestResponse: "RequestResponse";
+};
+export type ResponseStreamingInvocationType =
+  (typeof ResponseStreamingInvocationType)[keyof typeof ResponseStreamingInvocationType];
+export declare const FunctionVersion: {
+  readonly ALL: "ALL";
+};
+export type FunctionVersion =
+  (typeof FunctionVersion)[keyof typeof FunctionVersion];
+export declare const ProvisionedConcurrencyStatusEnum: {
+  readonly FAILED: "FAILED";
+  readonly IN_PROGRESS: "IN_PROGRESS";
+  readonly READY: "READY";
+};
+export type ProvisionedConcurrencyStatusEnum =
+  (typeof ProvisionedConcurrencyStatusEnum)[keyof typeof ProvisionedConcurrencyStatusEnum];

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

@@ -0,0 +1,357 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { ThrottleReason } from "./enums";
+import { LambdaServiceException as __BaseException } from "./LambdaServiceException";
+export declare class InvalidParameterValueException extends __BaseException {
+  readonly name: "InvalidParameterValueException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<InvalidParameterValueException, __BaseException>
+  );
+}
+export declare class PolicyLengthExceededException extends __BaseException {
+  readonly name: "PolicyLengthExceededException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<PolicyLengthExceededException, __BaseException>
+  );
+}
+export declare class PreconditionFailedException extends __BaseException {
+  readonly name: "PreconditionFailedException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<PreconditionFailedException, __BaseException>
+  );
+}
+export declare class ResourceConflictException extends __BaseException {
+  readonly name: "ResourceConflictException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<ResourceConflictException, __BaseException>
+  );
+}
+export declare class ResourceNotFoundException extends __BaseException {
+  readonly name: "ResourceNotFoundException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>
+  );
+}
+export declare class ServiceException extends __BaseException {
+  readonly name: "ServiceException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(opts: __ExceptionOptionType<ServiceException, __BaseException>);
+}
+export declare class TooManyRequestsException extends __BaseException {
+  readonly name: "TooManyRequestsException";
+  readonly $fault: "client";
+  retryAfterSeconds?: string | undefined;
+  Type?: string | undefined;
+  Reason?: ThrottleReason | undefined;
+  constructor(
+    opts: __ExceptionOptionType<TooManyRequestsException, __BaseException>
+  );
+}
+export declare class ResourceInUseException extends __BaseException {
+  readonly name: "ResourceInUseException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<ResourceInUseException, __BaseException>
+  );
+}
+export declare class CodeSigningConfigNotFoundException extends __BaseException {
+  readonly name: "CodeSigningConfigNotFoundException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<
+      CodeSigningConfigNotFoundException,
+      __BaseException
+    >
+  );
+}
+export declare class CodeStorageExceededException extends __BaseException {
+  readonly name: "CodeStorageExceededException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<CodeStorageExceededException, __BaseException>
+  );
+}
+export declare class CodeVerificationFailedException extends __BaseException {
+  readonly name: "CodeVerificationFailedException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<
+      CodeVerificationFailedException,
+      __BaseException
+    >
+  );
+}
+export declare class InvalidCodeSignatureException extends __BaseException {
+  readonly name: "InvalidCodeSignatureException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<InvalidCodeSignatureException, __BaseException>
+  );
+}
+export declare class EC2AccessDeniedException extends __BaseException {
+  readonly name: "EC2AccessDeniedException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<EC2AccessDeniedException, __BaseException>
+  );
+}
+export declare class EC2ThrottledException extends __BaseException {
+  readonly name: "EC2ThrottledException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<EC2ThrottledException, __BaseException>
+  );
+}
+export declare class EC2UnexpectedException extends __BaseException {
+  readonly name: "EC2UnexpectedException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  EC2ErrorCode?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<EC2UnexpectedException, __BaseException>
+  );
+}
+export declare class EFSIOException extends __BaseException {
+  readonly name: "EFSIOException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(opts: __ExceptionOptionType<EFSIOException, __BaseException>);
+}
+export declare class EFSMountConnectivityException extends __BaseException {
+  readonly name: "EFSMountConnectivityException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<EFSMountConnectivityException, __BaseException>
+  );
+}
+export declare class EFSMountFailureException extends __BaseException {
+  readonly name: "EFSMountFailureException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<EFSMountFailureException, __BaseException>
+  );
+}
+export declare class EFSMountTimeoutException extends __BaseException {
+  readonly name: "EFSMountTimeoutException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<EFSMountTimeoutException, __BaseException>
+  );
+}
+export declare class ENILimitReachedException extends __BaseException {
+  readonly name: "ENILimitReachedException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<ENILimitReachedException, __BaseException>
+  );
+}
+export declare class InvalidRequestContentException extends __BaseException {
+  readonly name: "InvalidRequestContentException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<InvalidRequestContentException, __BaseException>
+  );
+}
+export declare class InvalidRuntimeException extends __BaseException {
+  readonly name: "InvalidRuntimeException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<InvalidRuntimeException, __BaseException>
+  );
+}
+export declare class InvalidSecurityGroupIDException extends __BaseException {
+  readonly name: "InvalidSecurityGroupIDException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<
+      InvalidSecurityGroupIDException,
+      __BaseException
+    >
+  );
+}
+export declare class InvalidSubnetIDException extends __BaseException {
+  readonly name: "InvalidSubnetIDException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<InvalidSubnetIDException, __BaseException>
+  );
+}
+export declare class InvalidZipFileException extends __BaseException {
+  readonly name: "InvalidZipFileException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<InvalidZipFileException, __BaseException>
+  );
+}
+export declare class KMSAccessDeniedException extends __BaseException {
+  readonly name: "KMSAccessDeniedException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<KMSAccessDeniedException, __BaseException>
+  );
+}
+export declare class KMSDisabledException extends __BaseException {
+  readonly name: "KMSDisabledException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<KMSDisabledException, __BaseException>
+  );
+}
+export declare class KMSInvalidStateException extends __BaseException {
+  readonly name: "KMSInvalidStateException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<KMSInvalidStateException, __BaseException>
+  );
+}
+export declare class KMSNotFoundException extends __BaseException {
+  readonly name: "KMSNotFoundException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<KMSNotFoundException, __BaseException>
+  );
+}
+export declare class RecursiveInvocationException extends __BaseException {
+  readonly name: "RecursiveInvocationException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<RecursiveInvocationException, __BaseException>
+  );
+}
+export declare class RequestTooLargeException extends __BaseException {
+  readonly name: "RequestTooLargeException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<RequestTooLargeException, __BaseException>
+  );
+}
+export declare class ResourceNotReadyException extends __BaseException {
+  readonly name: "ResourceNotReadyException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<ResourceNotReadyException, __BaseException>
+  );
+}
+export declare class SerializedRequestEntityTooLargeException extends __BaseException {
+  readonly name: "SerializedRequestEntityTooLargeException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<
+      SerializedRequestEntityTooLargeException,
+      __BaseException
+    >
+  );
+}
+export declare class SnapStartException extends __BaseException {
+  readonly name: "SnapStartException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(opts: __ExceptionOptionType<SnapStartException, __BaseException>);
+}
+export declare class SnapStartNotReadyException extends __BaseException {
+  readonly name: "SnapStartNotReadyException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<SnapStartNotReadyException, __BaseException>
+  );
+}
+export declare class SnapStartTimeoutException extends __BaseException {
+  readonly name: "SnapStartTimeoutException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<SnapStartTimeoutException, __BaseException>
+  );
+}
+export declare class SubnetIPAddressLimitReachedException extends __BaseException {
+  readonly name: "SubnetIPAddressLimitReachedException";
+  readonly $fault: "server";
+  Type?: string | undefined;
+  Message?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<
+      SubnetIPAddressLimitReachedException,
+      __BaseException
+    >
+  );
+}
+export declare class UnsupportedMediaTypeException extends __BaseException {
+  readonly name: "UnsupportedMediaTypeException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<UnsupportedMediaTypeException, __BaseException>
+  );
+}
+export declare class ProvisionedConcurrencyConfigNotFoundException extends __BaseException {
+  readonly name: "ProvisionedConcurrencyConfigNotFoundException";
+  readonly $fault: "client";
+  Type?: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<
+      ProvisionedConcurrencyConfigNotFoundException,
+      __BaseException
+    >
+  );
+}