@aws-sdk/client-lambda/dist-cjs/index.js

AWS SDK for JavaScript Lambda Client for Node.js, Browser and React Native

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  AddLayerVersionPermissionCommand: () => AddLayerVersionPermissionCommand,
  AddPermissionCommand: () => AddPermissionCommand,
  ApplicationLogLevel: () => ApplicationLogLevel,
  Architecture: () => Architecture,
  CodeSigningConfigNotFoundException: () => CodeSigningConfigNotFoundException,
  CodeSigningPolicy: () => CodeSigningPolicy,
  CodeStorageExceededException: () => CodeStorageExceededException,
  CodeVerificationFailedException: () => CodeVerificationFailedException,
  CreateAliasCommand: () => CreateAliasCommand,
  CreateCodeSigningConfigCommand: () => CreateCodeSigningConfigCommand,
  CreateEventSourceMappingCommand: () => CreateEventSourceMappingCommand,
  CreateFunctionCommand: () => CreateFunctionCommand,
  CreateFunctionRequestFilterSensitiveLog: () => CreateFunctionRequestFilterSensitiveLog,
  CreateFunctionUrlConfigCommand: () => CreateFunctionUrlConfigCommand,
  DeleteAliasCommand: () => DeleteAliasCommand,
  DeleteCodeSigningConfigCommand: () => DeleteCodeSigningConfigCommand,
  DeleteEventSourceMappingCommand: () => DeleteEventSourceMappingCommand,
  DeleteFunctionCodeSigningConfigCommand: () => DeleteFunctionCodeSigningConfigCommand,
  DeleteFunctionCommand: () => DeleteFunctionCommand,
  DeleteFunctionConcurrencyCommand: () => DeleteFunctionConcurrencyCommand,
  DeleteFunctionEventInvokeConfigCommand: () => DeleteFunctionEventInvokeConfigCommand,
  DeleteFunctionUrlConfigCommand: () => DeleteFunctionUrlConfigCommand,
  DeleteLayerVersionCommand: () => DeleteLayerVersionCommand,
  DeleteProvisionedConcurrencyConfigCommand: () => DeleteProvisionedConcurrencyConfigCommand,
  EC2AccessDeniedException: () => EC2AccessDeniedException,
  EC2ThrottledException: () => EC2ThrottledException,
  EC2UnexpectedException: () => EC2UnexpectedException,
  EFSIOException: () => EFSIOException,
  EFSMountConnectivityException: () => EFSMountConnectivityException,
  EFSMountFailureException: () => EFSMountFailureException,
  EFSMountTimeoutException: () => EFSMountTimeoutException,
  ENILimitReachedException: () => ENILimitReachedException,
  EndPointType: () => EndPointType,
  EnvironmentErrorFilterSensitiveLog: () => EnvironmentErrorFilterSensitiveLog,
  EnvironmentFilterSensitiveLog: () => EnvironmentFilterSensitiveLog,
  EnvironmentResponseFilterSensitiveLog: () => EnvironmentResponseFilterSensitiveLog,
  EventSourceMappingMetric: () => EventSourceMappingMetric,
  EventSourcePosition: () => EventSourcePosition,
  FullDocument: () => FullDocument,
  FunctionCodeFilterSensitiveLog: () => FunctionCodeFilterSensitiveLog,
  FunctionConfigurationFilterSensitiveLog: () => FunctionConfigurationFilterSensitiveLog,
  FunctionResponseType: () => FunctionResponseType,
  FunctionUrlAuthType: () => FunctionUrlAuthType,
  FunctionVersion: () => FunctionVersion,
  GetAccountSettingsCommand: () => GetAccountSettingsCommand,
  GetAliasCommand: () => GetAliasCommand,
  GetCodeSigningConfigCommand: () => GetCodeSigningConfigCommand,
  GetEventSourceMappingCommand: () => GetEventSourceMappingCommand,
  GetFunctionCodeSigningConfigCommand: () => GetFunctionCodeSigningConfigCommand,
  GetFunctionCommand: () => GetFunctionCommand,
  GetFunctionConcurrencyCommand: () => GetFunctionConcurrencyCommand,
  GetFunctionConfigurationCommand: () => GetFunctionConfigurationCommand,
  GetFunctionEventInvokeConfigCommand: () => GetFunctionEventInvokeConfigCommand,
  GetFunctionRecursionConfigCommand: () => GetFunctionRecursionConfigCommand,
  GetFunctionResponseFilterSensitiveLog: () => GetFunctionResponseFilterSensitiveLog,
  GetFunctionUrlConfigCommand: () => GetFunctionUrlConfigCommand,
  GetLayerVersionByArnCommand: () => GetLayerVersionByArnCommand,
  GetLayerVersionCommand: () => GetLayerVersionCommand,
  GetLayerVersionPolicyCommand: () => GetLayerVersionPolicyCommand,
  GetPolicyCommand: () => GetPolicyCommand,
  GetProvisionedConcurrencyConfigCommand: () => GetProvisionedConcurrencyConfigCommand,
  GetRuntimeManagementConfigCommand: () => GetRuntimeManagementConfigCommand,
  ImageConfigErrorFilterSensitiveLog: () => ImageConfigErrorFilterSensitiveLog,
  ImageConfigResponseFilterSensitiveLog: () => ImageConfigResponseFilterSensitiveLog,
  InvalidCodeSignatureException: () => InvalidCodeSignatureException,
  InvalidParameterValueException: () => InvalidParameterValueException,
  InvalidRequestContentException: () => InvalidRequestContentException,
  InvalidRuntimeException: () => InvalidRuntimeException,
  InvalidSecurityGroupIDException: () => InvalidSecurityGroupIDException,
  InvalidSubnetIDException: () => InvalidSubnetIDException,
  InvalidZipFileException: () => InvalidZipFileException,
  InvocationRequestFilterSensitiveLog: () => InvocationRequestFilterSensitiveLog,
  InvocationResponseFilterSensitiveLog: () => InvocationResponseFilterSensitiveLog,
  InvocationType: () => InvocationType,
  InvokeAsyncCommand: () => InvokeAsyncCommand,
  InvokeAsyncRequestFilterSensitiveLog: () => InvokeAsyncRequestFilterSensitiveLog,
  InvokeCommand: () => InvokeCommand,
  InvokeMode: () => InvokeMode,
  InvokeResponseStreamUpdateFilterSensitiveLog: () => InvokeResponseStreamUpdateFilterSensitiveLog,
  InvokeWithResponseStreamCommand: () => InvokeWithResponseStreamCommand,
  InvokeWithResponseStreamRequestFilterSensitiveLog: () => InvokeWithResponseStreamRequestFilterSensitiveLog,
  InvokeWithResponseStreamResponseEvent: () => InvokeWithResponseStreamResponseEvent,
  InvokeWithResponseStreamResponseEventFilterSensitiveLog: () => InvokeWithResponseStreamResponseEventFilterSensitiveLog,
  InvokeWithResponseStreamResponseFilterSensitiveLog: () => InvokeWithResponseStreamResponseFilterSensitiveLog,
  KMSAccessDeniedException: () => KMSAccessDeniedException,
  KMSDisabledException: () => KMSDisabledException,
  KMSInvalidStateException: () => KMSInvalidStateException,
  KMSNotFoundException: () => KMSNotFoundException,
  KafkaSchemaRegistryAuthType: () => KafkaSchemaRegistryAuthType,
  KafkaSchemaValidationAttribute: () => KafkaSchemaValidationAttribute,
  Lambda: () => Lambda,
  LambdaClient: () => LambdaClient,
  LambdaServiceException: () => LambdaServiceException,
  LastUpdateStatus: () => LastUpdateStatus,
  LastUpdateStatusReasonCode: () => LastUpdateStatusReasonCode,
  LayerVersionContentInputFilterSensitiveLog: () => LayerVersionContentInputFilterSensitiveLog,
  ListAliasesCommand: () => ListAliasesCommand,
  ListCodeSigningConfigsCommand: () => ListCodeSigningConfigsCommand,
  ListEventSourceMappingsCommand: () => ListEventSourceMappingsCommand,
  ListFunctionEventInvokeConfigsCommand: () => ListFunctionEventInvokeConfigsCommand,
  ListFunctionUrlConfigsCommand: () => ListFunctionUrlConfigsCommand,
  ListFunctionsByCodeSigningConfigCommand: () => ListFunctionsByCodeSigningConfigCommand,
  ListFunctionsCommand: () => ListFunctionsCommand,
  ListFunctionsResponseFilterSensitiveLog: () => ListFunctionsResponseFilterSensitiveLog,
  ListLayerVersionsCommand: () => ListLayerVersionsCommand,
  ListLayersCommand: () => ListLayersCommand,
  ListProvisionedConcurrencyConfigsCommand: () => ListProvisionedConcurrencyConfigsCommand,
  ListTagsCommand: () => ListTagsCommand,
  ListVersionsByFunctionCommand: () => ListVersionsByFunctionCommand,
  ListVersionsByFunctionResponseFilterSensitiveLog: () => ListVersionsByFunctionResponseFilterSensitiveLog,
  LogFormat: () => LogFormat,
  LogType: () => LogType,
  PackageType: () => PackageType,
  PolicyLengthExceededException: () => PolicyLengthExceededException,
  PreconditionFailedException: () => PreconditionFailedException,
  ProvisionedConcurrencyConfigNotFoundException: () => ProvisionedConcurrencyConfigNotFoundException,
  ProvisionedConcurrencyStatusEnum: () => ProvisionedConcurrencyStatusEnum,
  PublishLayerVersionCommand: () => PublishLayerVersionCommand,
  PublishLayerVersionRequestFilterSensitiveLog: () => PublishLayerVersionRequestFilterSensitiveLog,
  PublishVersionCommand: () => PublishVersionCommand,
  PutFunctionCodeSigningConfigCommand: () => PutFunctionCodeSigningConfigCommand,
  PutFunctionConcurrencyCommand: () => PutFunctionConcurrencyCommand,
  PutFunctionEventInvokeConfigCommand: () => PutFunctionEventInvokeConfigCommand,
  PutFunctionRecursionConfigCommand: () => PutFunctionRecursionConfigCommand,
  PutProvisionedConcurrencyConfigCommand: () => PutProvisionedConcurrencyConfigCommand,
  PutRuntimeManagementConfigCommand: () => PutRuntimeManagementConfigCommand,
  RecursiveInvocationException: () => RecursiveInvocationException,
  RecursiveLoop: () => RecursiveLoop,
  RemoveLayerVersionPermissionCommand: () => RemoveLayerVersionPermissionCommand,
  RemovePermissionCommand: () => RemovePermissionCommand,
  RequestTooLargeException: () => RequestTooLargeException,
  ResourceConflictException: () => ResourceConflictException,
  ResourceInUseException: () => ResourceInUseException,
  ResourceNotFoundException: () => ResourceNotFoundException,
  ResourceNotReadyException: () => ResourceNotReadyException,
  ResponseStreamingInvocationType: () => ResponseStreamingInvocationType,
  Runtime: () => Runtime,
  RuntimeVersionConfigFilterSensitiveLog: () => RuntimeVersionConfigFilterSensitiveLog,
  RuntimeVersionErrorFilterSensitiveLog: () => RuntimeVersionErrorFilterSensitiveLog,
  SchemaRegistryEventRecordFormat: () => SchemaRegistryEventRecordFormat,
  ServiceException: () => ServiceException,
  SnapStartApplyOn: () => SnapStartApplyOn,
  SnapStartException: () => SnapStartException,
  SnapStartNotReadyException: () => SnapStartNotReadyException,
  SnapStartOptimizationStatus: () => SnapStartOptimizationStatus,
  SnapStartTimeoutException: () => SnapStartTimeoutException,
  SourceAccessType: () => SourceAccessType,
  State: () => State,
  StateReasonCode: () => StateReasonCode,
  SubnetIPAddressLimitReachedException: () => SubnetIPAddressLimitReachedException,
  SystemLogLevel: () => SystemLogLevel,
  TagResourceCommand: () => TagResourceCommand,
  ThrottleReason: () => ThrottleReason,
  TooManyRequestsException: () => TooManyRequestsException,
  TracingMode: () => TracingMode,
  UnsupportedMediaTypeException: () => UnsupportedMediaTypeException,
  UntagResourceCommand: () => UntagResourceCommand,
  UpdateAliasCommand: () => UpdateAliasCommand,
  UpdateCodeSigningConfigCommand: () => UpdateCodeSigningConfigCommand,
  UpdateEventSourceMappingCommand: () => UpdateEventSourceMappingCommand,
  UpdateFunctionCodeCommand: () => UpdateFunctionCodeCommand,
  UpdateFunctionCodeRequestFilterSensitiveLog: () => UpdateFunctionCodeRequestFilterSensitiveLog,
  UpdateFunctionConfigurationCommand: () => UpdateFunctionConfigurationCommand,
  UpdateFunctionConfigurationRequestFilterSensitiveLog: () => UpdateFunctionConfigurationRequestFilterSensitiveLog,
  UpdateFunctionEventInvokeConfigCommand: () => UpdateFunctionEventInvokeConfigCommand,
  UpdateFunctionUrlConfigCommand: () => UpdateFunctionUrlConfigCommand,
  UpdateRuntimeOn: () => UpdateRuntimeOn,
  __Client: () => import_smithy_client.Client,
  paginateListAliases: () => paginateListAliases,
  paginateListCodeSigningConfigs: () => paginateListCodeSigningConfigs,
  paginateListEventSourceMappings: () => paginateListEventSourceMappings,
  paginateListFunctionEventInvokeConfigs: () => paginateListFunctionEventInvokeConfigs,
  paginateListFunctionUrlConfigs: () => paginateListFunctionUrlConfigs,
  paginateListFunctions: () => paginateListFunctions,
  paginateListFunctionsByCodeSigningConfig: () => paginateListFunctionsByCodeSigningConfig,
  paginateListLayerVersions: () => paginateListLayerVersions,
  paginateListLayers: () => paginateListLayers,
  paginateListProvisionedConcurrencyConfigs: () => paginateListProvisionedConcurrencyConfigs,
  paginateListVersionsByFunction: () => paginateListVersionsByFunction,
  waitForFunctionActive: () => waitForFunctionActive,
  waitForFunctionActiveV2: () => waitForFunctionActiveV2,
  waitForFunctionExists: () => waitForFunctionExists,
  waitForFunctionUpdated: () => waitForFunctionUpdated,
  waitForFunctionUpdatedV2: () => waitForFunctionUpdatedV2,
  waitForPublishedVersionActive: () => waitForPublishedVersionActive,
  waitUntilFunctionActive: () => waitUntilFunctionActive,
  waitUntilFunctionActiveV2: () => waitUntilFunctionActiveV2,
  waitUntilFunctionExists: () => waitUntilFunctionExists,
  waitUntilFunctionUpdated: () => waitUntilFunctionUpdated,
  waitUntilFunctionUpdatedV2: () => waitUntilFunctionUpdatedV2,
  waitUntilPublishedVersionActive: () => waitUntilPublishedVersionActive
});
module.exports = __toCommonJS(index_exports);

// src/LambdaClient.ts
var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
var import_middleware_logger = require("@aws-sdk/middleware-logger");
var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core = require("@smithy/core");
var import_eventstream_serde_config_resolver = require("@smithy/eventstream-serde-config-resolver");
var import_middleware_content_length = require("@smithy/middleware-content-length");
var import_middleware_endpoint = require("@smithy/middleware-endpoint");
var import_middleware_retry = require("@smithy/middleware-retry");

var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");

// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
  return Object.assign(options, {
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "lambda"
  });
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};

// src/LambdaClient.ts
var import_runtimeConfig = require("././runtimeConfig");

// src/runtimeExtensions.ts
var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
var import_protocol_http = require("@smithy/protocol-http");
var import_smithy_client = require("@smithy/smithy-client");

// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
  let _credentials = runtimeConfig.credentials;
  return {
    setHttpAuthScheme(httpAuthScheme) {
      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
      if (index === -1) {
        _httpAuthSchemes.push(httpAuthScheme);
      } else {
        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
      }
    },
    httpAuthSchemes() {
      return _httpAuthSchemes;
    },
    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
      _httpAuthSchemeProvider = httpAuthSchemeProvider;
    },
    httpAuthSchemeProvider() {
      return _httpAuthSchemeProvider;
    },
    setCredentials(credentials) {
      _credentials = credentials;
    },
    credentials() {
      return _credentials;
    }
  };
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
  return {
    httpAuthSchemes: config.httpAuthSchemes(),
    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
    credentials: config.credentials()
  };
}, "resolveHttpAuthRuntimeConfig");

// src/runtimeExtensions.ts
var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
  const extensionConfiguration = Object.assign(
    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
    getHttpAuthExtensionConfiguration(runtimeConfig)
  );
  extensions.forEach((extension) => extension.configure(extensionConfiguration));
  return Object.assign(
    runtimeConfig,
    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
    resolveHttpAuthRuntimeConfig(extensionConfiguration)
  );
}, "resolveRuntimeExtensions");

// src/LambdaClient.ts
var LambdaClient = class extends import_smithy_client.Client {
  static {
    __name(this, "LambdaClient");
  }
  /**
   * The resolved configuration of LambdaClient class. This is resolved and normalized from the {@link LambdaClientConfig | constructor configuration interface}.
   */
  config;
  constructor(...[configuration]) {
    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
    super(_config_0);
    this.initConfig = _config_0;
    const _config_1 = resolveClientEndpointParameters(_config_0);
    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
    const _config_7 = (0, import_eventstream_serde_config_resolver.resolveEventStreamSerdeConfig)(_config_6);
    const _config_8 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_7);
    const _config_9 = resolveRuntimeExtensions(_config_8, configuration?.extensions || []);
    this.config = _config_9;
    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
    this.middlewareStack.use(
      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultLambdaHttpAuthSchemeParametersProvider,
        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
          "aws.auth#sigv4": config.credentials
        }), "identityProviderConfigProvider")
      })
    );
    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
  }
  /**
   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
   */
  destroy() {
    super.destroy();
  }
};

// src/Lambda.ts


// src/commands/AddLayerVersionPermissionCommand.ts

var import_middleware_serde = require("@smithy/middleware-serde");


// src/protocols/Aws_restJson1.ts
var import_core2 = require("@aws-sdk/core");



// src/models/LambdaServiceException.ts

var LambdaServiceException = class _LambdaServiceException extends import_smithy_client.ServiceException {
  static {
    __name(this, "LambdaServiceException");
  }
  /**
   * @internal
   */
  constructor(options) {
    super(options);
    Object.setPrototypeOf(this, _LambdaServiceException.prototype);
  }
};

// src/models/models_0.ts

var InvalidParameterValueException = class _InvalidParameterValueException extends LambdaServiceException {
  static {
    __name(this, "InvalidParameterValueException");
  }
  name = "InvalidParameterValueException";
  $fault = "client";
  /**
   * <p>The exception type.</p>
   * @public
   */
  Type;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidParameterValueException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidParameterValueException.prototype);
    this.Type = opts.Type;
  }
};
var PolicyLengthExceededException = class _PolicyLengthExceededException extends LambdaServiceException {
  static {
    __name(this, "PolicyLengthExceededException");
  }
  name = "PolicyLengthExceededException";
  $fault = "client";
  Type;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PolicyLengthExceededException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _PolicyLengthExceededException.prototype);
    this.Type = opts.Type;
  }
};
var PreconditionFailedException = class _PreconditionFailedException extends LambdaServiceException {
  static {
    __name(this, "PreconditionFailedException");
  }
  name = "PreconditionFailedException";
  $fault = "client";
  /**
   * <p>The exception type.</p>
   * @public
   */
  Type;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PreconditionFailedException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _PreconditionFailedException.prototype);
    this.Type = opts.Type;
  }
};
var ResourceConflictException = class _ResourceConflictException extends LambdaServiceException {
  static {
    __name(this, "ResourceConflictException");
  }
  name = "ResourceConflictException";
  $fault = "client";
  /**
   * <p>The exception type.</p>
   * @public
   */
  Type;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceConflictException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ResourceConflictException.prototype);
    this.Type = opts.Type;
  }
};
var ResourceNotFoundException = class _ResourceNotFoundException extends LambdaServiceException {
  static {
    __name(this, "ResourceNotFoundException");
  }
  name = "ResourceNotFoundException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceNotFoundException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var ServiceException = class _ServiceException extends LambdaServiceException {
  static {
    __name(this, "ServiceException");
  }
  name = "ServiceException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ServiceException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _ServiceException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var ThrottleReason = {
  CallerRateLimitExceeded: "CallerRateLimitExceeded",
  ConcurrentInvocationLimitExceeded: "ConcurrentInvocationLimitExceeded",
  ConcurrentSnapshotCreateLimitExceeded: "ConcurrentSnapshotCreateLimitExceeded",
  FunctionInvocationRateLimitExceeded: "FunctionInvocationRateLimitExceeded",
  ReservedFunctionConcurrentInvocationLimitExceeded: "ReservedFunctionConcurrentInvocationLimitExceeded",
  ReservedFunctionInvocationRateLimitExceeded: "ReservedFunctionInvocationRateLimitExceeded"
};
var TooManyRequestsException = class _TooManyRequestsException extends LambdaServiceException {
  static {
    __name(this, "TooManyRequestsException");
  }
  name = "TooManyRequestsException";
  $fault = "client";
  /**
   * <p>The number of seconds the caller should wait before retrying.</p>
   * @public
   */
  retryAfterSeconds;
  Type;
  Reason;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TooManyRequestsException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
    this.retryAfterSeconds = opts.retryAfterSeconds;
    this.Type = opts.Type;
    this.Reason = opts.Reason;
  }
};
var FunctionUrlAuthType = {
  AWS_IAM: "AWS_IAM",
  NONE: "NONE"
};
var KafkaSchemaRegistryAuthType = {
  BASIC_AUTH: "BASIC_AUTH",
  CLIENT_CERTIFICATE_TLS_AUTH: "CLIENT_CERTIFICATE_TLS_AUTH",
  SERVER_ROOT_CA_CERTIFICATE: "SERVER_ROOT_CA_CERTIFICATE"
};
var SchemaRegistryEventRecordFormat = {
  JSON: "JSON",
  SOURCE: "SOURCE"
};
var KafkaSchemaValidationAttribute = {
  KEY: "KEY",
  VALUE: "VALUE"
};
var ApplicationLogLevel = {
  Debug: "DEBUG",
  Error: "ERROR",
  Fatal: "FATAL",
  Info: "INFO",
  Trace: "TRACE",
  Warn: "WARN"
};
var Architecture = {
  arm64: "arm64",
  x86_64: "x86_64"
};
var CodeSigningPolicy = {
  Enforce: "Enforce",
  Warn: "Warn"
};
var FullDocument = {
  Default: "Default",
  UpdateLookup: "UpdateLookup"
};
var FunctionResponseType = {
  ReportBatchItemFailures: "ReportBatchItemFailures"
};
var EventSourceMappingMetric = {
  EventCount: "EventCount"
};
var EndPointType = {
  KAFKA_BOOTSTRAP_SERVERS: "KAFKA_BOOTSTRAP_SERVERS"
};
var SourceAccessType = {
  BASIC_AUTH: "BASIC_AUTH",
  CLIENT_CERTIFICATE_TLS_AUTH: "CLIENT_CERTIFICATE_TLS_AUTH",
  SASL_SCRAM_256_AUTH: "SASL_SCRAM_256_AUTH",
  SASL_SCRAM_512_AUTH: "SASL_SCRAM_512_AUTH",
  SERVER_ROOT_CA_CERTIFICATE: "SERVER_ROOT_CA_CERTIFICATE",
  VIRTUAL_HOST: "VIRTUAL_HOST",
  VPC_SECURITY_GROUP: "VPC_SECURITY_GROUP",
  VPC_SUBNET: "VPC_SUBNET"
};
var EventSourcePosition = {
  AT_TIMESTAMP: "AT_TIMESTAMP",
  LATEST: "LATEST",
  TRIM_HORIZON: "TRIM_HORIZON"
};
var ResourceInUseException = class _ResourceInUseException extends LambdaServiceException {
  static {
    __name(this, "ResourceInUseException");
  }
  name = "ResourceInUseException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceInUseException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ResourceInUseException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var CodeSigningConfigNotFoundException = class _CodeSigningConfigNotFoundException extends LambdaServiceException {
  static {
    __name(this, "CodeSigningConfigNotFoundException");
  }
  name = "CodeSigningConfigNotFoundException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CodeSigningConfigNotFoundException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CodeSigningConfigNotFoundException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var CodeStorageExceededException = class _CodeStorageExceededException extends LambdaServiceException {
  static {
    __name(this, "CodeStorageExceededException");
  }
  name = "CodeStorageExceededException";
  $fault = "client";
  /**
   * <p>The exception type.</p>
   * @public
   */
  Type;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CodeStorageExceededException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CodeStorageExceededException.prototype);
    this.Type = opts.Type;
  }
};
var CodeVerificationFailedException = class _CodeVerificationFailedException extends LambdaServiceException {
  static {
    __name(this, "CodeVerificationFailedException");
  }
  name = "CodeVerificationFailedException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CodeVerificationFailedException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _CodeVerificationFailedException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var LogFormat = {
  Json: "JSON",
  Text: "Text"
};
var SystemLogLevel = {
  Debug: "DEBUG",
  Info: "INFO",
  Warn: "WARN"
};
var PackageType = {
  Image: "Image",
  Zip: "Zip"
};
var Runtime = {
  dotnet6: "dotnet6",
  dotnet8: "dotnet8",
  dotnetcore10: "dotnetcore1.0",
  dotnetcore20: "dotnetcore2.0",
  dotnetcore21: "dotnetcore2.1",
  dotnetcore31: "dotnetcore3.1",
  go1x: "go1.x",
  java11: "java11",
  java17: "java17",
  java21: "java21",
  java8: "java8",
  java8al2: "java8.al2",
  nodejs: "nodejs",
  nodejs10x: "nodejs10.x",
  nodejs12x: "nodejs12.x",
  nodejs14x: "nodejs14.x",
  nodejs16x: "nodejs16.x",
  nodejs18x: "nodejs18.x",
  nodejs20x: "nodejs20.x",
  nodejs22x: "nodejs22.x",
  nodejs43: "nodejs4.3",
  nodejs43edge: "nodejs4.3-edge",
  nodejs610: "nodejs6.10",
  nodejs810: "nodejs8.10",
  provided: "provided",
  providedal2: "provided.al2",
  providedal2023: "provided.al2023",
  python27: "python2.7",
  python310: "python3.10",
  python311: "python3.11",
  python312: "python3.12",
  python313: "python3.13",
  python36: "python3.6",
  python37: "python3.7",
  python38: "python3.8",
  python39: "python3.9",
  ruby25: "ruby2.5",
  ruby27: "ruby2.7",
  ruby32: "ruby3.2",
  ruby33: "ruby3.3",
  ruby34: "ruby3.4"
};
var SnapStartApplyOn = {
  None: "None",
  PublishedVersions: "PublishedVersions"
};
var TracingMode = {
  Active: "Active",
  PassThrough: "PassThrough"
};
var LastUpdateStatus = {
  Failed: "Failed",
  InProgress: "InProgress",
  Successful: "Successful"
};
var LastUpdateStatusReasonCode = {
  DisabledKMSKey: "DisabledKMSKey",
  EFSIOError: "EFSIOError",
  EFSMountConnectivityError: "EFSMountConnectivityError",
  EFSMountFailure: "EFSMountFailure",
  EFSMountTimeout: "EFSMountTimeout",
  EniLimitExceeded: "EniLimitExceeded",
  FunctionError: "FunctionError",
  ImageAccessDenied: "ImageAccessDenied",
  ImageDeleted: "ImageDeleted",
  InsufficientRolePermissions: "InsufficientRolePermissions",
  InternalError: "InternalError",
  InvalidConfiguration: "InvalidConfiguration",
  InvalidImage: "InvalidImage",
  InvalidRuntime: "InvalidRuntime",
  InvalidSecurityGroup: "InvalidSecurityGroup",
  InvalidStateKMSKey: "InvalidStateKMSKey",
  InvalidSubnet: "InvalidSubnet",
  InvalidZipFileException: "InvalidZipFileException",
  KMSKeyAccessDenied: "KMSKeyAccessDenied",
  KMSKeyNotFound: "KMSKeyNotFound",
  SubnetOutOfIPAddresses: "SubnetOutOfIPAddresses"
};
var SnapStartOptimizationStatus = {
  Off: "Off",
  On: "On"
};
var State = {
  Active: "Active",
  Failed: "Failed",
  Inactive: "Inactive",
  Pending: "Pending"
};
var StateReasonCode = {
  Creating: "Creating",
  DisabledKMSKey: "DisabledKMSKey",
  EFSIOError: "EFSIOError",
  EFSMountConnectivityError: "EFSMountConnectivityError",
  EFSMountFailure: "EFSMountFailure",
  EFSMountTimeout: "EFSMountTimeout",
  EniLimitExceeded: "EniLimitExceeded",
  FunctionError: "FunctionError",
  Idle: "Idle",
  ImageAccessDenied: "ImageAccessDenied",
  ImageDeleted: "ImageDeleted",
  InsufficientRolePermissions: "InsufficientRolePermissions",
  InternalError: "InternalError",
  InvalidConfiguration: "InvalidConfiguration",
  InvalidImage: "InvalidImage",
  InvalidRuntime: "InvalidRuntime",
  InvalidSecurityGroup: "InvalidSecurityGroup",
  InvalidStateKMSKey: "InvalidStateKMSKey",
  InvalidSubnet: "InvalidSubnet",
  InvalidZipFileException: "InvalidZipFileException",
  KMSKeyAccessDenied: "KMSKeyAccessDenied",
  KMSKeyNotFound: "KMSKeyNotFound",
  Restoring: "Restoring",
  SubnetOutOfIPAddresses: "SubnetOutOfIPAddresses"
};
var InvalidCodeSignatureException = class _InvalidCodeSignatureException extends LambdaServiceException {
  static {
    __name(this, "InvalidCodeSignatureException");
  }
  name = "InvalidCodeSignatureException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidCodeSignatureException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidCodeSignatureException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var InvokeMode = {
  BUFFERED: "BUFFERED",
  RESPONSE_STREAM: "RESPONSE_STREAM"
};
var RecursiveLoop = {
  Allow: "Allow",
  Terminate: "Terminate"
};
var UpdateRuntimeOn = {
  Auto: "Auto",
  FunctionUpdate: "FunctionUpdate",
  Manual: "Manual"
};
var EC2AccessDeniedException = class _EC2AccessDeniedException extends LambdaServiceException {
  static {
    __name(this, "EC2AccessDeniedException");
  }
  name = "EC2AccessDeniedException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "EC2AccessDeniedException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _EC2AccessDeniedException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var EC2ThrottledException = class _EC2ThrottledException extends LambdaServiceException {
  static {
    __name(this, "EC2ThrottledException");
  }
  name = "EC2ThrottledException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "EC2ThrottledException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _EC2ThrottledException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var EC2UnexpectedException = class _EC2UnexpectedException extends LambdaServiceException {
  static {
    __name(this, "EC2UnexpectedException");
  }
  name = "EC2UnexpectedException";
  $fault = "server";
  Type;
  Message;
  EC2ErrorCode;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "EC2UnexpectedException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _EC2UnexpectedException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
    this.EC2ErrorCode = opts.EC2ErrorCode;
  }
};
var EFSIOException = class _EFSIOException extends LambdaServiceException {
  static {
    __name(this, "EFSIOException");
  }
  name = "EFSIOException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "EFSIOException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _EFSIOException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var EFSMountConnectivityException = class _EFSMountConnectivityException extends LambdaServiceException {
  static {
    __name(this, "EFSMountConnectivityException");
  }
  name = "EFSMountConnectivityException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "EFSMountConnectivityException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _EFSMountConnectivityException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var EFSMountFailureException = class _EFSMountFailureException extends LambdaServiceException {
  static {
    __name(this, "EFSMountFailureException");
  }
  name = "EFSMountFailureException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "EFSMountFailureException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _EFSMountFailureException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var EFSMountTimeoutException = class _EFSMountTimeoutException extends LambdaServiceException {
  static {
    __name(this, "EFSMountTimeoutException");
  }
  name = "EFSMountTimeoutException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "EFSMountTimeoutException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _EFSMountTimeoutException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var ENILimitReachedException = class _ENILimitReachedException extends LambdaServiceException {
  static {
    __name(this, "ENILimitReachedException");
  }
  name = "ENILimitReachedException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ENILimitReachedException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _ENILimitReachedException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var InvalidRequestContentException = class _InvalidRequestContentException extends LambdaServiceException {
  static {
    __name(this, "InvalidRequestContentException");
  }
  name = "InvalidRequestContentException";
  $fault = "client";
  /**
   * <p>The exception type.</p>
   * @public
   */
  Type;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidRequestContentException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidRequestContentException.prototype);
    this.Type = opts.Type;
  }
};
var InvalidRuntimeException = class _InvalidRuntimeException extends LambdaServiceException {
  static {
    __name(this, "InvalidRuntimeException");
  }
  name = "InvalidRuntimeException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidRuntimeException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidRuntimeException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var InvalidSecurityGroupIDException = class _InvalidSecurityGroupIDException extends LambdaServiceException {
  static {
    __name(this, "InvalidSecurityGroupIDException");
  }
  name = "InvalidSecurityGroupIDException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidSecurityGroupIDException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidSecurityGroupIDException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var InvalidSubnetIDException = class _InvalidSubnetIDException extends LambdaServiceException {
  static {
    __name(this, "InvalidSubnetIDException");
  }
  name = "InvalidSubnetIDException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidSubnetIDException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidSubnetIDException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var InvalidZipFileException = class _InvalidZipFileException extends LambdaServiceException {
  static {
    __name(this, "InvalidZipFileException");
  }
  name = "InvalidZipFileException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidZipFileException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidZipFileException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var InvocationType = {
  DryRun: "DryRun",
  Event: "Event",
  RequestResponse: "RequestResponse"
};
var LogType = {
  None: "None",
  Tail: "Tail"
};
var KMSAccessDeniedException = class _KMSAccessDeniedException extends LambdaServiceException {
  static {
    __name(this, "KMSAccessDeniedException");
  }
  name = "KMSAccessDeniedException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KMSAccessDeniedException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _KMSAccessDeniedException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var KMSDisabledException = class _KMSDisabledException extends LambdaServiceException {
  static {
    __name(this, "KMSDisabledException");
  }
  name = "KMSDisabledException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KMSDisabledException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _KMSDisabledException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var KMSInvalidStateException = class _KMSInvalidStateException extends LambdaServiceException {
  static {
    __name(this, "KMSInvalidStateException");
  }
  name = "KMSInvalidStateException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KMSInvalidStateException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _KMSInvalidStateException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var KMSNotFoundException = class _KMSNotFoundException extends LambdaServiceException {
  static {
    __name(this, "KMSNotFoundException");
  }
  name = "KMSNotFoundException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KMSNotFoundException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _KMSNotFoundException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var RecursiveInvocationException = class _RecursiveInvocationException extends LambdaServiceException {
  static {
    __name(this, "RecursiveInvocationException");
  }
  name = "RecursiveInvocationException";
  $fault = "client";
  /**
   * <p>The exception type.</p>
   * @public
   */
  Type;
  /**
   * <p>The exception message.</p>
   * @public
   */
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "RecursiveInvocationException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _RecursiveInvocationException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var RequestTooLargeException = class _RequestTooLargeException extends LambdaServiceException {
  static {
    __name(this, "RequestTooLargeException");
  }
  name = "RequestTooLargeException";
  $fault = "client";
  Type;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "RequestTooLargeException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _RequestTooLargeException.prototype);
    this.Type = opts.Type;
  }
};
var ResourceNotReadyException = class _ResourceNotReadyException extends LambdaServiceException {
  static {
    __name(this, "ResourceNotReadyException");
  }
  name = "ResourceNotReadyException";
  $fault = "server";
  /**
   * <p>The exception type.</p>
   * @public
   */
  Type;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceNotReadyException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _ResourceNotReadyException.prototype);
    this.Type = opts.Type;
  }
};
var SnapStartException = class _SnapStartException extends LambdaServiceException {
  static {
    __name(this, "SnapStartException");
  }
  name = "SnapStartException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "SnapStartException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _SnapStartException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var SnapStartNotReadyException = class _SnapStartNotReadyException extends LambdaServiceException {
  static {
    __name(this, "SnapStartNotReadyException");
  }
  name = "SnapStartNotReadyException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "SnapStartNotReadyException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _SnapStartNotReadyException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var SnapStartTimeoutException = class _SnapStartTimeoutException extends LambdaServiceException {
  static {
    __name(this, "SnapStartTimeoutException");
  }
  name = "SnapStartTimeoutException";
  $fault = "client";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "SnapStartTimeoutException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _SnapStartTimeoutException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var SubnetIPAddressLimitReachedException = class _SubnetIPAddressLimitReachedException extends LambdaServiceException {
  static {
    __name(this, "SubnetIPAddressLimitReachedException");
  }
  name = "SubnetIPAddressLimitReachedException";
  $fault = "server";
  Type;
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "SubnetIPAddressLimitReachedException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _SubnetIPAddressLimitReachedException.prototype);
    this.Type = opts.Type;
    this.Message = opts.Message;
  }
};
var UnsupportedMediaTypeException = class _UnsupportedMediaTypeException extends LambdaServiceException {
  static {
    __name(this, "UnsupportedMediaTypeException");
  }
  name = "UnsupportedMediaTypeException";
  $fault = "client";
  Type;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnsupportedMediaTypeException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _UnsupportedMediaTypeException.prototype);
    this.Type = opts.Type;
  }
};
var ResponseStreamingInvocationType = {
  DryRun: "DryRun",
  RequestResponse: "RequestResponse"
};
var InvokeWithResponseStreamResponseEvent;
((InvokeWithResponseStreamResponseEvent3) => {
  InvokeWithResponseStreamResponseEvent3.visit = /* @__PURE__ */ __name((value, visitor) => {
    if (value.PayloadChunk !== void 0) return visitor.PayloadChunk(value.PayloadChunk);
    if (value.InvokeComplete !== void 0) return visitor.InvokeComplete(value.InvokeComplete);
    return visitor._(value.$unknown[0], value.$unknown[1]);
  }, "visit");
})(InvokeWithResponseStreamResponseEvent || (InvokeWithResponseStreamResponseEvent = {}));
var FunctionVersion = {
  ALL: "ALL"
};
var ProvisionedConcurrencyStatusEnum = {
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS",
  READY: "READY"
};
var ProvisionedConcurrencyConfigNotFoundException = class _ProvisionedConcurrencyConfigNotFoundException extends LambdaServiceException {
  static {
    __name(this, "ProvisionedConcurrencyConfigNotFoundException");
  }
  name = "ProvisionedConcurrencyConfigNotFoundException";
  $fault = "client";
  Type;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ProvisionedConcurrencyConfigNotFoundException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ProvisionedConcurrencyConfigNotFoundException.prototype);
    this.Type = opts.Type;
  }
};
var FunctionCodeFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ZipFile && { ZipFile: import_smithy_client.SENSITIVE_STRING }
}), "FunctionCodeFilterSensitiveLog");
var EnvironmentFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Variables && { Variables: import_smithy_client.SENSITIVE_STRING }
}), "EnvironmentFilterSensitiveLog");
var CreateFunctionRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Code && { Code: FunctionCodeFilterSensitiveLog(obj.Code) },
  ...obj.Environment && { Environment: EnvironmentFilterSensitiveLog(obj.Environment) }
}), "CreateFunctionRequestFilterSensitiveLog");
var EnvironmentErrorFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Message && { Message: import_smithy_client.SENSITIVE_STRING }
}), "EnvironmentErrorFilterSensitiveLog");
var EnvironmentResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Variables && { Variables: import_smithy_client.SENSITIVE_STRING },
  ...obj.Error && { Error: EnvironmentErrorFilterSensitiveLog(obj.Error) }
}), "EnvironmentResponseFilterSensitiveLog");
var ImageConfigErrorFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Message && { Message: import_smithy_client.SENSITIVE_STRING }
}), "ImageConfigErrorFilterSensitiveLog");
var ImageConfigResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Error && { Error: ImageConfigErrorFilterSensitiveLog(obj.Error) }
}), "ImageConfigResponseFilterSensitiveLog");
var RuntimeVersionErrorFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Message && { Message: import_smithy_client.SENSITIVE_STRING }
}), "RuntimeVersionErrorFilterSensitiveLog");
var RuntimeVersionConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Error && { Error: RuntimeVersionErrorFilterSensitiveLog(obj.Error) }
}), "Run