"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) }
}), "RuntimeVersionConfigFilterSensitiveLog");
var FunctionConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Environment && { Environment: EnvironmentResponseFilterSensitiveLog(obj.Environment) },
  ...obj.ImageConfigResponse && {
    ImageConfigResponse: ImageConfigResponseFilterSensitiveLog(obj.ImageConfigResponse)
  },
  ...obj.RuntimeVersionConfig && {
    RuntimeVersionConfig: RuntimeVersionConfigFilterSensitiveLog(obj.RuntimeVersionConfig)
  }
}), "FunctionConfigurationFilterSensitiveLog");
var GetFunctionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Configuration && { Configuration: FunctionConfigurationFilterSensitiveLog(obj.Configuration) }
}), "GetFunctionResponseFilterSensitiveLog");
var InvocationRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Payload && { Payload: import_smithy_client.SENSITIVE_STRING }
}), "InvocationRequestFilterSensitiveLog");
var InvocationResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Payload && { Payload: import_smithy_client.SENSITIVE_STRING }
}), "InvocationResponseFilterSensitiveLog");
var InvokeAsyncRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj
}), "InvokeAsyncRequestFilterSensitiveLog");
var InvokeWithResponseStreamRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Payload && { Payload: import_smithy_client.SENSITIVE_STRING }
}), "InvokeWithResponseStreamRequestFilterSensitiveLog");
var InvokeResponseStreamUpdateFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Payload && { Payload: import_smithy_client.SENSITIVE_STRING }
}), "InvokeResponseStreamUpdateFilterSensitiveLog");
var InvokeWithResponseStreamResponseEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
  if (obj.PayloadChunk !== void 0)
    return { PayloadChunk: InvokeResponseStreamUpdateFilterSensitiveLog(obj.PayloadChunk) };
  if (obj.InvokeComplete !== void 0) return { InvokeComplete: obj.InvokeComplete };
  if (obj.$unknown !== void 0) return { [obj.$unknown[0]]: "UNKNOWN" };
}, "InvokeWithResponseStreamResponseEventFilterSensitiveLog");
var InvokeWithResponseStreamResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.EventStream && { EventStream: "STREAMING_CONTENT" }
}), "InvokeWithResponseStreamResponseFilterSensitiveLog");
var ListFunctionsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Functions && { Functions: obj.Functions.map((item) => FunctionConfigurationFilterSensitiveLog(item)) }
}), "ListFunctionsResponseFilterSensitiveLog");
var UpdateFunctionCodeRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ZipFile && { ZipFile: import_smithy_client.SENSITIVE_STRING }
}), "UpdateFunctionCodeRequestFilterSensitiveLog");
var UpdateFunctionConfigurationRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Environment && { Environment: EnvironmentFilterSensitiveLog(obj.Environment) }
}), "UpdateFunctionConfigurationRequestFilterSensitiveLog");
var ListVersionsByFunctionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Versions && { Versions: obj.Versions.map((item) => FunctionConfigurationFilterSensitiveLog(item)) }
}), "ListVersionsByFunctionResponseFilterSensitiveLog");
var LayerVersionContentInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ZipFile && { ZipFile: import_smithy_client.SENSITIVE_STRING }
}), "LayerVersionContentInputFilterSensitiveLog");
var PublishLayerVersionRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Content && { Content: LayerVersionContentInputFilterSensitiveLog(obj.Content) }
}), "PublishLayerVersionRequestFilterSensitiveLog");

// src/protocols/Aws_restJson1.ts
var se_AddLayerVersionPermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy");
  b.p("LayerName", () => input.LayerName, "{LayerName}", false);
  b.p("VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
  const query = (0, import_smithy_client.map)({
    [_RI]: [, input[_RI]]
  });
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      Action: [],
      OrganizationId: [],
      Principal: [],
      StatementId: []
    })
  );
  b.m("POST").h(headers).q(query).b(body);
  return b.build();
}, "se_AddLayerVersionPermissionCommand");
var se_AddPermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2015-03-31/functions/{FunctionName}/policy");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      Action: [],
      EventSourceToken: [],
      FunctionUrlAuthType: [],
      Principal: [],
      PrincipalOrgID: [],
      RevisionId: [],
      SourceAccount: [],
      SourceArn: [],
      StatementId: []
    })
  );
  b.m("POST").h(headers).q(query).b(body);
  return b.build();
}, "se_AddPermissionCommand");
var se_CreateAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2015-03-31/functions/{FunctionName}/aliases");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      Description: [],
      FunctionVersion: [],
      Name: [],
      RoutingConfig: /* @__PURE__ */ __name((_) => se_AliasRoutingConfiguration(_, context), "RoutingConfig")
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateAliasCommand");
var se_CreateCodeSigningConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2020-04-22/code-signing-configs");
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      AllowedPublishers: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "AllowedPublishers"),
      CodeSigningPolicies: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "CodeSigningPolicies"),
      Description: [],
      Tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tags")
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateCodeSigningConfigCommand");
var se_CreateEventSourceMappingCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2015-03-31/event-source-mappings");
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      AmazonManagedKafkaEventSourceConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "AmazonManagedKafkaEventSourceConfig"),
      BatchSize: [],
      BisectBatchOnFunctionError: [],
      DestinationConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "DestinationConfig"),
      DocumentDBEventSourceConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "DocumentDBEventSourceConfig"),
      Enabled: [],
      EventSourceArn: [],
      FilterCriteria: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "FilterCriteria"),
      FunctionName: [],
      FunctionResponseTypes: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "FunctionResponseTypes"),
      KMSKeyArn: [],
      MaximumBatchingWindowInSeconds: [],
      MaximumRecordAgeInSeconds: [],
      MaximumRetryAttempts: [],
      MetricsConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "MetricsConfig"),
      ParallelizationFactor: [],
      ProvisionedPollerConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ProvisionedPollerConfig"),
      Queues: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Queues"),
      ScalingConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ScalingConfig"),
      SelfManagedEventSource: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SelfManagedEventSource"),
      SelfManagedKafkaEventSourceConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SelfManagedKafkaEventSourceConfig"),
      SourceAccessConfigurations: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SourceAccessConfigurations"),
      StartingPosition: [],
      StartingPositionTimestamp: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "StartingPositionTimestamp"),
      Tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tags"),
      Topics: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Topics"),
      TumblingWindowInSeconds: []
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateEventSourceMappingCommand");
var se_CreateFunctionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2015-03-31/functions");
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      Architectures: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Architectures"),
      Code: /* @__PURE__ */ __name((_) => se_FunctionCode(_, context), "Code"),
      CodeSigningConfigArn: [],
      DeadLetterConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "DeadLetterConfig"),
      Description: [],
      Environment: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Environment"),
      EphemeralStorage: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "EphemeralStorage"),
      FileSystemConfigs: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "FileSystemConfigs"),
      FunctionName: [],
      Handler: [],
      ImageConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ImageConfig"),
      KMSKeyArn: [],
      Layers: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Layers"),
      LoggingConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "LoggingConfig"),
      MemorySize: [],
      PackageType: [],
      Publish: [],
      Role: [],
      Runtime: [],
      SnapStart: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SnapStart"),
      Tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tags"),
      Timeout: [],
      TracingConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "TracingConfig"),
      VpcConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "VpcConfig")
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateFunctionCommand");
var se_CreateFunctionUrlConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2021-10-31/functions/{FunctionName}/url");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      AuthType: [],
      Cors: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Cors"),
      InvokeMode: []
    })
  );
  b.m("POST").h(headers).q(query).b(body);
  return b.build();
}, "se_CreateFunctionUrlConfigCommand");
var se_DeleteAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/functions/{FunctionName}/aliases/{Name}");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  b.p("Name", () => input.Name, "{Name}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteAliasCommand");
var se_DeleteCodeSigningConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2020-04-22/code-signing-configs/{CodeSigningConfigArn}");
  b.p("CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteCodeSigningConfigCommand");
var se_DeleteEventSourceMappingCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/event-source-mappings/{UUID}");
  b.p("UUID", () => input.UUID, "{UUID}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteEventSourceMappingCommand");
var se_DeleteFunctionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/functions/{FunctionName}");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  b.m("DELETE").h(headers).q(query).b(body);
  return b.build();
}, "se_DeleteFunctionCommand");
var se_DeleteFunctionCodeSigningConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2020-06-30/functions/{FunctionName}/code-signing-config");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteFunctionCodeSigningConfigCommand");
var se_DeleteFunctionConcurrencyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2017-10-31/functions/{FunctionName}/concurrency");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteFunctionConcurrencyCommand");
var se_DeleteFunctionEventInvokeConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2019-09-25/functions/{FunctionName}/event-invoke-config");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  b.m("DELETE").h(headers).q(query).b(body);
  return b.build();
}, "se_DeleteFunctionEventInvokeConfigCommand");
var se_DeleteFunctionUrlConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2021-10-31/functions/{FunctionName}/url");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  b.m("DELETE").h(headers).q(query).b(body);
  return b.build();
}, "se_DeleteFunctionUrlConfigCommand");
var se_DeleteLayerVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2018-10-31/layers/{LayerName}/versions/{VersionNumber}");
  b.p("LayerName", () => input.LayerName, "{LayerName}", false);
  b.p("VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteLayerVersionCommand");
var se_DeleteProvisionedConcurrencyConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2019-09-30/functions/{FunctionName}/provisioned-concurrency");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, (0, import_smithy_client.expectNonNull)(input[_Q], `Qualifier`)]
  });
  let body;
  b.m("DELETE").h(headers).q(query).b(body);
  return b.build();
}, "se_DeleteProvisionedConcurrencyConfigCommand");
var se_GetAccountSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2016-08-19/account-settings");
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_GetAccountSettingsCommand");
var se_GetAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/functions/{FunctionName}/aliases/{Name}");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  b.p("Name", () => input.Name, "{Name}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_GetAliasCommand");
var se_GetCodeSigningConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2020-04-22/code-signing-configs/{CodeSigningConfigArn}");
  b.p("CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_GetCodeSigningConfigCommand");
var se_GetEventSourceMappingCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/event-source-mappings/{UUID}");
  b.p("UUID", () => input.UUID, "{UUID}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_GetEventSourceMappingCommand");
var se_GetFunctionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/functions/{FunctionName}");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_GetFunctionCommand");
var se_GetFunctionCodeSigningConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2020-06-30/functions/{FunctionName}/code-signing-config");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_GetFunctionCodeSigningConfigCommand");
var se_GetFunctionConcurrencyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2019-09-30/functions/{FunctionName}/concurrency");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_GetFunctionConcurrencyCommand");
var se_GetFunctionConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/functions/{FunctionName}/configuration");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_GetFunctionConfigurationCommand");
var se_GetFunctionEventInvokeConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2019-09-25/functions/{FunctionName}/event-invoke-config");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_GetFunctionEventInvokeConfigCommand");
var se_GetFunctionRecursionConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2024-08-31/functions/{FunctionName}/recursion-config");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_GetFunctionRecursionConfigCommand");
var se_GetFunctionUrlConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2021-10-31/functions/{FunctionName}/url");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_GetFunctionUrlConfigCommand");
var se_GetLayerVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2018-10-31/layers/{LayerName}/versions/{VersionNumber}");
  b.p("LayerName", () => input.LayerName, "{LayerName}", false);
  b.p("VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_GetLayerVersionCommand");
var se_GetLayerVersionByArnCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2018-10-31/layers");
  const query = (0, import_smithy_client.map)({
    [_f]: [, "LayerVersion"],
    [_A]: [, (0, import_smithy_client.expectNonNull)(input[_A], `Arn`)]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_GetLayerVersionByArnCommand");
var se_GetLayerVersionPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy");
  b.p("LayerName", () => input.LayerName, "{LayerName}", false);
  b.p("VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_GetLayerVersionPolicyCommand");
var se_GetPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/functions/{FunctionName}/policy");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_GetPolicyCommand");
var se_GetProvisionedConcurrencyConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2019-09-30/functions/{FunctionName}/provisioned-concurrency");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, (0, import_smithy_client.expectNonNull)(input[_Q], `Qualifier`)]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_GetProvisionedConcurrencyConfigCommand");
var se_GetRuntimeManagementConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2021-07-20/functions/{FunctionName}/runtime-management-config");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_GetRuntimeManagementConfigCommand");
var se_InvokeCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = (0, import_smithy_client.map)({}, import_smithy_client.isSerializableHeaderValue, {
    "content-type": "application/octet-stream",
    [_xait]: input[_IT],
    [_xalt]: input[_LT],
    [_xacc]: input[_CC]
  });
  b.bp("/2015-03-31/functions/{FunctionName}/invocations");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  if (input.Payload !== void 0) {
    body = input.Payload;
  }
  b.m("POST").h(headers).q(query).b(body);
  return b.build();
}, "se_InvokeCommand");
var se_InvokeAsyncCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/octet-stream"
  };
  b.bp("/2014-11-13/functions/{FunctionName}/invoke-async");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  if (input.InvokeArgs !== void 0) {
    body = input.InvokeArgs;
  }
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_InvokeAsyncCommand");
var se_InvokeWithResponseStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = (0, import_smithy_client.map)({}, import_smithy_client.isSerializableHeaderValue, {
    "content-type": "application/octet-stream",
    [_xait]: input[_IT],
    [_xalt]: input[_LT],
    [_xacc]: input[_CC]
  });
  b.bp("/2021-11-15/functions/{FunctionName}/response-streaming-invocations");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  if (input.Payload !== void 0) {
    body = input.Payload;
  }
  b.m("POST").h(headers).q(query).b(body);
  return b.build();
}, "se_InvokeWithResponseStreamCommand");
var se_ListAliasesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/functions/{FunctionName}/aliases");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_FV]: [, input[_FV]],
    [_M]: [, input[_M]],
    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListAliasesCommand");
var se_ListCodeSigningConfigsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2020-04-22/code-signing-configs");
  const query = (0, import_smithy_client.map)({
    [_M]: [, input[_M]],
    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListCodeSigningConfigsCommand");
var se_ListEventSourceMappingsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/event-source-mappings");
  const query = (0, import_smithy_client.map)({
    [_ESA]: [, input[_ESA]],
    [_FN]: [, input[_FN]],
    [_M]: [, input[_M]],
    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListEventSourceMappingsCommand");
var se_ListFunctionEventInvokeConfigsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2019-09-25/functions/{FunctionName}/event-invoke-config/list");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_M]: [, input[_M]],
    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListFunctionEventInvokeConfigsCommand");
var se_ListFunctionsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/functions");
  const query = (0, import_smithy_client.map)({
    [_MR]: [, input[_MR]],
    [_FV]: [, input[_FV]],
    [_M]: [, input[_M]],
    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListFunctionsCommand");
var se_ListFunctionsByCodeSigningConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2020-04-22/code-signing-configs/{CodeSigningConfigArn}/functions");
  b.p("CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", false);
  const query = (0, import_smithy_client.map)({
    [_M]: [, input[_M]],
    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListFunctionsByCodeSigningConfigCommand");
var se_ListFunctionUrlConfigsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2021-10-31/functions/{FunctionName}/urls");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_M]: [, input[_M]],
    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListFunctionUrlConfigsCommand");
var se_ListLayersCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2018-10-31/layers");
  const query = (0, import_smithy_client.map)({
    [_CR]: [, input[_CR]],
    [_M]: [, input[_M]],
    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()],
    [_CA]: [, input[_CA]]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListLayersCommand");
var se_ListLayerVersionsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2018-10-31/layers/{LayerName}/versions");
  b.p("LayerName", () => input.LayerName, "{LayerName}", false);
  const query = (0, import_smithy_client.map)({
    [_CR]: [, input[_CR]],
    [_M]: [, input[_M]],
    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()],
    [_CA]: [, input[_CA]]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListLayerVersionsCommand");
var se_ListProvisionedConcurrencyConfigsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2019-09-30/functions/{FunctionName}/provisioned-concurrency");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_L]: [, "ALL"],
    [_M]: [, input[_M]],
    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListProvisionedConcurrencyConfigsCommand");
var se_ListTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2017-03-31/tags/{Resource}");
  b.p("Resource", () => input.Resource, "{Resource}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_ListTagsCommand");
var se_ListVersionsByFunctionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/functions/{FunctionName}/versions");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_M]: [, input[_M]],
    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListVersionsByFunctionCommand");
var se_PublishLayerVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2018-10-31/layers/{LayerName}/versions");
  b.p("LayerName", () => input.LayerName, "{LayerName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      CompatibleArchitectures: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "CompatibleArchitectures"),
      CompatibleRuntimes: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "CompatibleRuntimes"),
      Content: /* @__PURE__ */ __name((_) => se_LayerVersionContentInput(_, context), "Content"),
      Description: [],
      LicenseInfo: []
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_PublishLayerVersionCommand");
var se_PublishVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2015-03-31/functions/{FunctionName}/versions");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      CodeSha256: [],
      Description: [],
      RevisionId: []
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_PublishVersionCommand");
var se_PutFunctionCodeSigningConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2020-06-30/functions/{FunctionName}/code-signing-config");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      CodeSigningConfigArn: []
    })
  );
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_PutFunctionCodeSigningConfigCommand");
var se_PutFunctionConcurrencyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2017-10-31/functions/{FunctionName}/concurrency");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      ReservedConcurrentExecutions: []
    })
  );
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_PutFunctionConcurrencyCommand");
var se_PutFunctionEventInvokeConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2019-09-25/functions/{FunctionName}/event-invoke-config");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      DestinationConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "DestinationConfig"),
      MaximumEventAgeInSeconds: [],
      MaximumRetryAttempts: []
    })
  );
  b.m("PUT").h(headers).q(query).b(body);
  return b.build();
}, "se_PutFunctionEventInvokeConfigCommand");
var se_PutFunctionRecursionConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2024-08-31/functions/{FunctionName}/recursion-config");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      RecursiveLoop: []
    })
  );
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_PutFunctionRecursionConfigCommand");
var se_PutProvisionedConcurrencyConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2019-09-30/functions/{FunctionName}/provisioned-concurrency");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, (0, import_smithy_client.expectNonNull)(input[_Q], `Qualifier`)]
  });
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      ProvisionedConcurrentExecutions: []
    })
  );
  b.m("PUT").h(headers).q(query).b(body);
  return b.build();
}, "se_PutProvisionedConcurrencyConfigCommand");
var se_PutRuntimeManagementConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2021-07-20/functions/{FunctionName}/runtime-management-config");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      RuntimeVersionArn: [],
      UpdateRuntimeOn: []
    })
  );
  b.m("PUT").h(headers).q(query).b(body);
  return b.build();
}, "se_PutRuntimeManagementConfigCommand");
var se_RemoveLayerVersionPermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy/{StatementId}");
  b.p("LayerName", () => input.LayerName, "{LayerName}", false);
  b.p("VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
  b.p("StatementId", () => input.StatementId, "{StatementId}", false);
  const query = (0, import_smithy_client.map)({
    [_RI]: [, input[_RI]]
  });
  let body;
  b.m("DELETE").h(headers).q(query).b(body);
  return b.build();
}, "se_RemoveLayerVersionPermissionCommand");
var se_RemovePermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2015-03-31/functions/{FunctionName}/policy/{StatementId}");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  b.p("StatementId", () => input.StatementId, "{StatementId}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]],
    [_RI]: [, input[_RI]]
  });
  let body;
  b.m("DELETE").h(headers).q(query).b(body);
  return b.build();
}, "se_RemovePermissionCommand");
var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2017-03-31/tags/{Resource}");
  b.p("Resource", () => input.Resource, "{Resource}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      Tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tags")
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_TagResourceCommand");
var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/2017-03-31/tags/{Resource}");
  b.p("Resource", () => input.Resource, "{Resource}", false);
  const query = (0, import_smithy_client.map)({
    [_tK]: [(0, import_smithy_client.expectNonNull)(input.TagKeys, `TagKeys`) != null, () => input[_TK] || []]
  });
  let body;
  b.m("DELETE").h(headers).q(query).b(body);
  return b.build();
}, "se_UntagResourceCommand");
var se_UpdateAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2015-03-31/functions/{FunctionName}/aliases/{Name}");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  b.p("Name", () => input.Name, "{Name}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      Description: [],
      FunctionVersion: [],
      RevisionId: [],
      RoutingConfig: /* @__PURE__ */ __name((_) => se_AliasRoutingConfiguration(_, context), "RoutingConfig")
    })
  );
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_UpdateAliasCommand");
var se_UpdateCodeSigningConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2020-04-22/code-signing-configs/{CodeSigningConfigArn}");
  b.p("CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      AllowedPublishers: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "AllowedPublishers"),
      CodeSigningPolicies: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "CodeSigningPolicies"),
      Description: []
    })
  );
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_UpdateCodeSigningConfigCommand");
var se_UpdateEventSourceMappingCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2015-03-31/event-source-mappings/{UUID}");
  b.p("UUID", () => input.UUID, "{UUID}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      AmazonManagedKafkaEventSourceConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "AmazonManagedKafkaEventSourceConfig"),
      BatchSize: [],
      BisectBatchOnFunctionError: [],
      DestinationConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "DestinationConfig"),
      DocumentDBEventSourceConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "DocumentDBEventSourceConfig"),
      Enabled: [],
      FilterCriteria: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "FilterCriteria"),
      FunctionName: [],
      FunctionResponseTypes: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "FunctionResponseTypes"),
      KMSKeyArn: [],
      MaximumBatchingWindowInSeconds: [],
      MaximumRecordAgeInSeconds: [],
      MaximumRetryAttempts: [],
      MetricsConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "MetricsConfig"),
      ParallelizationFactor: [],
      ProvisionedPollerConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ProvisionedPollerConfig"),
      ScalingConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ScalingConfig"),
      SelfManagedKafkaEventSourceConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SelfManagedKafkaEventSourceConfig"),
      SourceAccessConfigurations: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SourceAccessConfigurations"),
      TumblingWindowInSeconds: []
    })
  );
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_UpdateEventSourceMappingCommand");
var se_UpdateFunctionCodeCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2015-03-31/functions/{FunctionName}/code");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      Architectures: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Architectures"),
      DryRun: [],
      ImageUri: [],
      Publish: [],
      RevisionId: [],
      S3Bucket: [],
      S3Key: [],
      S3ObjectVersion: [],
      SourceKMSKeyArn: [],
      ZipFile: /* @__PURE__ */ __name((_) => context.base64Encoder(_), "ZipFile")
    })
  );
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_UpdateFunctionCodeCommand");
var se_UpdateFunctionConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2015-03-31/functions/{FunctionName}/configuration");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      DeadLetterConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "DeadLetterConfig"),
      Description: [],
      Environment: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Environment"),
      EphemeralStorage: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "EphemeralStorage"),
      FileSystemConfigs: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "FileSystemConfigs"),
      Handler: [],
      ImageConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ImageConfig"),
      KMSKeyArn: [],
      Layers: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Layers"),
      LoggingConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "LoggingConfig"),
      MemorySize: [],
      RevisionId: [],
      Role: [],
      Runtime: [],
      SnapStart: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SnapStart"),
      Timeout: [],
      TracingConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "TracingConfig"),
      VpcConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "VpcConfig")
    })
  );
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_UpdateFunctionConfigurationCommand");
var se_UpdateFunctionEventInvokeConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2019-09-25/functions/{FunctionName}/event-invoke-config");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      DestinationConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "DestinationConfig"),
      MaximumEventAgeInSeconds: [],
      MaximumRetryAttempts: []
    })
  );
  b.m("POST").h(headers).q(query).b(body);
  return b.build();
}, "se_UpdateFunctionEventInvokeConfigCommand");
var se_UpdateFunctionUrlConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/2021-10-31/functions/{FunctionName}/url");
  b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
  const query = (0, import_smithy_client.map)({
    [_Q]: [, input[_Q]]
  });
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      AuthType: [],
      Cors: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Cors"),
      InvokeMode: []
    })
  );
  b.m("PUT").h(headers).q(query).b(body);
  return b.build();
}, "se_UpdateFunctionUrlConfigCommand");
var de_AddLayerVersionPermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 201 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    RevisionId: import_smithy_client.expectString,
    Statement: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_AddLayerVersionPermissionCommand");
var de_AddPermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 201 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Statement: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_AddPermissionCommand");
var de_CreateAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 201 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AliasArn: import_smithy_client.expectString,
    Description: import_smithy_client.expectString,
    FunctionVersion: import_smithy_client.expectString,
    Name: import_smithy_client.expectString,
    RevisionId: import_smithy_client.expectString,
    RoutingConfig: /* @__PURE__ */ __name((_) => de_AliasRoutingConfiguration(_, context), "RoutingConfig")
  });
  Object.assign(contents, doc);
  return contents;
}, "de_CreateAliasCommand");
var de_CreateCodeSigningConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 201 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    CodeSigningConfig: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_CreateCodeSigningConfigCommand");
var de_CreateEventSourceMappingCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 202 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AmazonManagedKafkaEventSourceConfig: import_smithy_client._json,
    BatchSize: import_smithy_client.expectInt32,
    BisectBatchOnFunctionError: import_smithy_client.expectBoolean,
    DestinationConfig: import_smithy_client._json,
    DocumentDBEventSourceConfig: import_smithy_client._json,
    EventSourceArn: import_smithy_client.expectString,
    EventSourceMappingArn: import_smithy_client.expectString,
    FilterCriteria: import_smithy_client._json,
    FilterCriteriaError: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    FunctionResponseTypes: import_smithy_client._json,
    KMSKeyArn: import_smithy_client.expectString,
    LastModified: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastModified"),
    LastProcessingResult: import_smithy_client.expectString,
    MaximumBatchingWindowInSeconds: import_smithy_client.expectInt32,
    MaximumRecordAgeInSeconds: import_smithy_client.expectInt32,
    MaximumRetryAttempts: import_smithy_client.expectInt32,
    MetricsConfig: import_smithy_client._json,
    ParallelizationFactor: import_smithy_client.expectInt32,
    ProvisionedPollerConfig: import_smithy_client._json,
    Queues: import_smithy_client._json,
    ScalingConfig: import_smithy_client._json,
    SelfManagedEventSource: import_smithy_client._json,
    SelfManagedKafkaEventSourceConfig: import_smithy_client._json,
    SourceAccessConfigurations: import_smithy_client._json,
    StartingPosition: import_smithy_client.expectString,
    StartingPositionTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "StartingPositionTimestamp"),
    State: import_smithy_client.expectString,
    StateTransitionReason: import_smithy_client.expectString,
    Topics: import_smithy_client._json,
    TumblingWindowInSeconds: import_smithy_client.expectInt32,
    UUID: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_CreateEventSourceMappingCommand");
var de_CreateFunctionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 201 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Architectures: import_smithy_client._json,
    CodeSha256: import_smithy_client.expectString,
    CodeSize: import_smithy_client.expectLong,
    DeadLetterConfig: import_smithy_client._json,
    Description: import_smithy_client.expectString,
    Environment: import_smithy_client._json,
    EphemeralStorage: import_smithy_client._json,
    FileSystemConfigs: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    FunctionName: import_smithy_client.expectString,
    Handler: import_smithy_client.expectString,
    ImageConfigResponse: import_smithy_client._json,
    KMSKeyArn: import_smithy_client.expectString,
    LastModified: import_smithy_client.expectString,
    LastUpdateStatus: import_smithy_client.expectString,
    LastUpdateStatusReason: import_smithy_client.expectString,
    LastUpdateStatusReasonCode: import_smithy_client.expectString,
    Layers: import_smithy_client._json,
    LoggingConfig: import_smithy_client._json,
    MasterArn: import_smithy_client.expectString,
    MemorySize: import_smithy_client.expectInt32,
    PackageType: import_smithy_client.expectString,
    RevisionId: import_smithy_client.expectString,
    Role: import_smithy_client.expectString,
    Runtime: import_smithy_client.expectString,
    RuntimeVersionConfig: import_smithy_client._json,
    SigningJobArn: import_smithy_client.expectString,
    SigningProfileVersionArn: import_smithy_client.expectString,
    SnapStart: import_smithy_client._json,
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString,
    StateReasonCode: import_smithy_client.expectString,
    Timeout: import_smithy_client.expectInt32,
    TracingConfig: import_smithy_client._json,
    Version: import_smithy_client.expectString,
    VpcConfig: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_CreateFunctionCommand");
var de_CreateFunctionUrlConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 201 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AuthType: import_smithy_client.expectString,
    Cors: import_smithy_client._json,
    CreationTime: import_smithy_client.expectString,
    FunctionArn: import_smithy_client.expectString,
    FunctionUrl: import_smithy_client.expectString,
    InvokeMode: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_CreateFunctionUrlConfigCommand");
var de_DeleteAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_DeleteAliasCommand");
var de_DeleteCodeSigningConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_DeleteCodeSigningConfigCommand");
var de_DeleteEventSourceMappingCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 202 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AmazonManagedKafkaEventSourceConfig: import_smithy_client._json,
    BatchSize: import_smithy_client.expectInt32,
    BisectBatchOnFunctionError: import_smithy_client.expectBoolean,
    DestinationConfig: import_smithy_client._json,
    DocumentDBEventSourceConfig: import_smithy_client._json,
    EventSourceArn: import_smithy_client.expectString,
    EventSourceMappingArn: import_smithy_client.expectString,
    FilterCriteria: import_smithy_client._json,
    FilterCriteriaError: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    FunctionResponseTypes: import_smithy_client._json,
    KMSKeyArn: import_smithy_client.expectString,
    LastModified: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastModified"),
    LastProcessingResult: import_smithy_client.expectString,
    MaximumBatchingWindowInSeconds: import_smithy_client.expectInt32,
    MaximumRecordAgeInSeconds: import_smithy_client.expectInt32,
    MaximumRetryAttempts: import_smithy_client.expectInt32,
    MetricsConfig: import_smithy_client._json,
    ParallelizationFactor: import_smithy_client.expectInt32,
    ProvisionedPollerConfig: import_smithy_client._json,
    Queues: import_smithy_client._json,
    ScalingConfig: import_smithy_client._json,
    SelfManagedEventSource: import_smithy_client._json,
    SelfManagedKafkaEventSourceConfig: import_smithy_client._json,
    SourceAccessConfigurations: import_smithy_client._json,
    StartingPosition: import_smithy_client.expectString,
    StartingPositionTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "StartingPositionTimestamp"),
    State: import_smithy_client.expectString,
    StateTransitionReason: import_smithy_client.expectString,
    Topics: import_smithy_client._json,
    TumblingWindowInSeconds: import_smithy_client.expectInt32,
    UUID: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_DeleteEventSourceMappingCommand");
var de_DeleteFunctionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_DeleteFunctionCommand");
var de_DeleteFunctionCodeSigningConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_DeleteFunctionCodeSigningConfigCommand");
var de_DeleteFunctionConcurrencyCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_DeleteFunctionConcurrencyCommand");
var de_DeleteFunctionEventInvokeConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_DeleteFunctionEventInvokeConfigCommand");
var de_DeleteFunctionUrlConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_DeleteFunctionUrlConfigCommand");
var de_DeleteLayerVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_DeleteLayerVersionCommand");
var de_DeleteProvisionedConcurrencyConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_DeleteProvisionedConcurrencyConfigCommand");
var de_GetAccountSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AccountLimit: import_smithy_client._json,
    AccountUsage: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetAccountSettingsCommand");
var de_GetAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AliasArn: import_smithy_client.expectString,
    Description: import_smithy_client.expectString,
    FunctionVersion: import_smithy_client.expectString,
    Name: import_smithy_client.expectString,
    RevisionId: import_smithy_client.expectString,
    RoutingConfig: /* @__PURE__ */ __name((_) => de_AliasRoutingConfiguration(_, context), "RoutingConfig")
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetAliasCommand");
var de_GetCodeSigningConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    CodeSigningConfig: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetCodeSigningConfigCommand");
var de_GetEventSourceMappingCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AmazonManagedKafkaEventSourceConfig: import_smithy_client._json,
    BatchSize: import_smithy_client.expectInt32,
    BisectBatchOnFunctionError: import_smithy_client.expectBoolean,
    DestinationConfig: import_smithy_client._json,
    DocumentDBEventSourceConfig: import_smithy_client._json,
    EventSourceArn: import_smithy_client.expectString,
    EventSourceMappingArn: import_smithy_client.expectString,
    FilterCriteria: import_smithy_client._json,
    FilterCriteriaError: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    FunctionResponseTypes: import_smithy_client._json,
    KMSKeyArn: import_smithy_client.expectString,
    LastModified: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastModified"),
    LastProcessingResult: import_smithy_client.expectString,
    MaximumBatchingWindowInSeconds: import_smithy_client.expectInt32,
    MaximumRecordAgeInSeconds: import_smithy_client.expectInt32,
    MaximumRetryAttempts: import_smithy_client.expectInt32,
    MetricsConfig: import_smithy_client._json,
    ParallelizationFactor: import_smithy_client.expectInt32,
    ProvisionedPollerConfig: import_smithy_client._json,
    Queues: import_smithy_client._json,
    ScalingConfig: import_smithy_client._json,
    SelfManagedEventSource: import_smithy_client._json,
    SelfManagedKafkaEventSourceConfig: import_smithy_client._json,
    SourceAccessConfigurations: import_smithy_client._json,
    StartingPosition: import_smithy_client.expectString,
    StartingPositionTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "StartingPositionTimestamp"),
    State: import_smithy_client.expectString,
    StateTransitionReason: import_smithy_client.expectString,
    Topics: import_smithy_client._json,
    TumblingWindowInSeconds: import_smithy_client.expectInt32,
    UUID: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetEventSourceMappingCommand");
var de_GetFunctionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Code: import_smithy_client._json,
    Concurrency: import_smithy_client._json,
    Configuration: import_smithy_client._json,
    Tags: import_smithy_client._json,
    TagsError: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetFunctionCommand");
var de_GetFunctionCodeSigningConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    CodeSigningConfigArn: import_smithy_client.expectString,
    FunctionName: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetFunctionCodeSigningConfigCommand");
var de_GetFunctionConcurrencyCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    ReservedConcurrentExecutions: import_smithy_client.expectInt32
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetFunctionConcurrencyCommand");
var de_GetFunctionConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Architectures: import_smithy_client._json,
    CodeSha256: import_smithy_client.expectString,
    CodeSize: import_smithy_client.expectLong,
    DeadLetterConfig: import_smithy_client._json,
    Description: import_smithy_client.expectString,
    Environment: import_smithy_client._json,
    EphemeralStorage: import_smithy_client._json,
    FileSystemConfigs: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    FunctionName: import_smithy_client.expectString,
    Handler: import_smithy_client.expectString,
    ImageConfigResponse: import_smithy_client._json,
    KMSKeyArn: import_smithy_client.expectString,
    LastModified: import_smithy_client.expectString,
    LastUpdateStatus: import_smithy_client.expectString,
    LastUpdateStatusReason: import_smithy_client.expectString,
    LastUpdateStatusReasonCode: import_smithy_client.expectString,
    Layers: import_smithy_client._json,
    LoggingConfig: import_smithy_client._json,
    MasterArn: import_smithy_client.expectString,
    MemorySize: import_smithy_client.expectInt32,
    PackageType: import_smithy_client.expectString,
    RevisionId: import_smithy_client.expectString,
    Role: import_smithy_client.expectString,
    Runtime: import_smithy_client.expectString,
    RuntimeVersionConfig: import_smithy_client._json,
    SigningJobArn: import_smithy_client.expectString,
    SigningProfileVersionArn: import_smithy_client.expectString,
    SnapStart: import_smithy_client._json,
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString,
    StateReasonCode: import_smithy_client.expectString,
    Timeout: import_smithy_client.expectInt32,
    TracingConfig: import_smithy_client._json,
    Version: import_smithy_client.expectString,
    VpcConfig: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetFunctionConfigurationCommand");
var de_GetFunctionEventInvokeConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    DestinationConfig: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    LastModified: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastModified"),
    MaximumEventAgeInSeconds: import_smithy_client.expectInt32,
    MaximumRetryAttempts: import_smithy_client.expectInt32
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetFunctionEventInvokeConfigCommand");
var de_GetFunctionRecursionConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    RecursiveLoop: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetFunctionRecursionConfigCommand");
var de_GetFunctionUrlConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AuthType: import_smithy_client.expectString,
    Cors: import_smithy_client._json,
    CreationTime: import_smithy_client.expectString,
    FunctionArn: import_smithy_client.expectString,
    FunctionUrl: import_smithy_client.expectString,
    InvokeMode: import_smithy_client.expectString,
    LastModifiedTime: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetFunctionUrlConfigCommand");
var de_GetLayerVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    CompatibleArchitectures: import_smithy_client._json,
    CompatibleRuntimes: import_smithy_client._json,
    Content: import_smithy_client._json,
    CreatedDate: import_smithy_client.expectString,
    Description: import_smithy_client.expectString,
    LayerArn: import_smithy_client.expectString,
    LayerVersionArn: import_smithy_client.expectString,
    LicenseInfo: import_smithy_client.expectString,
    Version: import_smithy_client.expectLong
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetLayerVersionCommand");
var de_GetLayerVersionByArnCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    CompatibleArchitectures: import_smithy_client._json,
    CompatibleRuntimes: import_smithy_client._json,
    Content: import_smithy_client._json,
    CreatedDate: import_smithy_client.expectString,
    Description: import_smithy_client.expectString,
    LayerArn: import_smithy_client.expectString,
    LayerVersionArn: import_smithy_client.expectString,
    LicenseInfo: import_smithy_client.expectString,
    Version: import_smithy_client.expectLong
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetLayerVersionByArnCommand");
var de_GetLayerVersionPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Policy: import_smithy_client.expectString,
    RevisionId: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetLayerVersionPolicyCommand");
var de_GetPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Policy: import_smithy_client.expectString,
    RevisionId: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetPolicyCommand");
var de_GetProvisionedConcurrencyConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AllocatedProvisionedConcurrentExecutions: import_smithy_client.expectInt32,
    AvailableProvisionedConcurrentExecutions: import_smithy_client.expectInt32,
    LastModified: import_smithy_client.expectString,
    RequestedProvisionedConcurrentExecutions: import_smithy_client.expectInt32,
    Status: import_smithy_client.expectString,
    StatusReason: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetProvisionedConcurrencyConfigCommand");
var de_GetRuntimeManagementConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    FunctionArn: import_smithy_client.expectString,
    RuntimeVersionArn: import_smithy_client.expectString,
    UpdateRuntimeOn: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_GetRuntimeManagementConfigCommand");
var de_InvokeCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output),
    [_FE]: [, output.headers[_xafe]],
    [_LR]: [, output.headers[_xalr]],
    [_EV]: [, output.headers[_xaev]]
  });
  const data = await (0, import_smithy_client.collectBody)(output.body, context);
  contents.Payload = data;
  (0, import_smithy_client.map)(contents, {
    StatusCode: [, output.statusCode]
  });
  return contents;
}, "de_InvokeCommand");
var de_InvokeAsyncCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 202 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  (0, import_smithy_client.map)(contents, {
    Status: [, output.statusCode]
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_InvokeAsyncCommand");
var de_InvokeWithResponseStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output),
    [_EV]: [, output.headers[_xaev]],
    [_RSCT]: [, output.headers[_ct]]
  });
  const data = output.body;
  contents.EventStream = de_InvokeWithResponseStreamResponseEvent(data, context);
  (0, import_smithy_client.map)(contents, {
    StatusCode: [, output.statusCode]
  });
  return contents;
}, "de_InvokeWithResponseStreamCommand");
var de_ListAliasesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Aliases: /* @__PURE__ */ __name((_) => de_AliasList(_, context), "Aliases"),
    NextMarker: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListAliasesCommand");
var de_ListCodeSigningConfigsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    CodeSigningConfigs: import_smithy_client._json,
    NextMarker: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListCodeSigningConfigsCommand");
var de_ListEventSourceMappingsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    EventSourceMappings: /* @__PURE__ */ __name((_) => de_EventSourceMappingsList(_, context), "EventSourceMappings"),
    NextMarker: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListEventSourceMappingsCommand");
var de_ListFunctionEventInvokeConfigsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    FunctionEventInvokeConfigs: /* @__PURE__ */ __name((_) => de_FunctionEventInvokeConfigList(_, context), "FunctionEventInvokeConfigs"),
    NextMarker: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListFunctionEventInvokeConfigsCommand");
var de_ListFunctionsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Functions: import_smithy_client._json,
    NextMarker: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListFunctionsCommand");
var de_ListFunctionsByCodeSigningConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    FunctionArns: import_smithy_client._json,
    NextMarker: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListFunctionsByCodeSigningConfigCommand");
var de_ListFunctionUrlConfigsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    FunctionUrlConfigs: import_smithy_client._json,
    NextMarker: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListFunctionUrlConfigsCommand");
var de_ListLayersCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Layers: import_smithy_client._json,
    NextMarker: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListLayersCommand");
var de_ListLayerVersionsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    LayerVersions: import_smithy_client._json,
    NextMarker: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListLayerVersionsCommand");
var de_ListProvisionedConcurrencyConfigsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    NextMarker: import_smithy_client.expectString,
    ProvisionedConcurrencyConfigs: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListProvisionedConcurrencyConfigsCommand");
var de_ListTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Tags: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListTagsCommand");
var de_ListVersionsByFunctionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    NextMarker: import_smithy_client.expectString,
    Versions: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListVersionsByFunctionCommand");
var de_PublishLayerVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 201 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    CompatibleArchitectures: import_smithy_client._json,
    CompatibleRuntimes: import_smithy_client._json,
    Content: import_smithy_client._json,
    CreatedDate: import_smithy_client.expectString,
    Description: import_smithy_client.expectString,
    LayerArn: import_smithy_client.expectString,
    LayerVersionArn: import_smithy_client.expectString,
    LicenseInfo: import_smithy_client.expectString,
    Version: import_smithy_client.expectLong
  });
  Object.assign(contents, doc);
  return contents;
}, "de_PublishLayerVersionCommand");
var de_PublishVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 201 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Architectures: import_smithy_client._json,
    CodeSha256: import_smithy_client.expectString,
    CodeSize: import_smithy_client.expectLong,
    DeadLetterConfig: import_smithy_client._json,
    Description: import_smithy_client.expectString,
    Environment: import_smithy_client._json,
    EphemeralStorage: import_smithy_client._json,
    FileSystemConfigs: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    FunctionName: import_smithy_client.expectString,
    Handler: import_smithy_client.expectString,
    ImageConfigResponse: import_smithy_client._json,
    KMSKeyArn: import_smithy_client.expectString,
    LastModified: import_smithy_client.expectString,
    LastUpdateStatus: import_smithy_client.expectString,
    LastUpdateStatusReason: import_smithy_client.expectString,
    LastUpdateStatusReasonCode: import_smithy_client.expectString,
    Layers: import_smithy_client._json,
    LoggingConfig: import_smithy_client._json,
    MasterArn: import_smithy_client.expectString,
    MemorySize: import_smithy_client.expectInt32,
    PackageType: import_smithy_client.expectString,
    RevisionId: import_smithy_client.expectString,
    Role: import_smithy_client.expectString,
    Runtime: import_smithy_client.expectString,
    RuntimeVersionConfig: import_smithy_client._json,
    SigningJobArn: import_smithy_client.expectString,
    SigningProfileVersionArn: import_smithy_client.expectString,
    SnapStart: import_smithy_client._json,
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString,
    StateReasonCode: import_smithy_client.expectString,
    Timeout: import_smithy_client.expectInt32,
    TracingConfig: import_smithy_client._json,
    Version: import_smithy_client.expectString,
    VpcConfig: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_PublishVersionCommand");
var de_PutFunctionCodeSigningConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    CodeSigningConfigArn: import_smithy_client.expectString,
    FunctionName: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_PutFunctionCodeSigningConfigCommand");
var de_PutFunctionConcurrencyCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    ReservedConcurrentExecutions: import_smithy_client.expectInt32
  });
  Object.assign(contents, doc);
  return contents;
}, "de_PutFunctionConcurrencyCommand");
var de_PutFunctionEventInvokeConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    DestinationConfig: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    LastModified: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastModified"),
    MaximumEventAgeInSeconds: import_smithy_client.expectInt32,
    MaximumRetryAttempts: import_smithy_client.expectInt32
  });
  Object.assign(contents, doc);
  return contents;
}, "de_PutFunctionEventInvokeConfigCommand");
var de_PutFunctionRecursionConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    RecursiveLoop: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_PutFunctionRecursionConfigCommand");
var de_PutProvisionedConcurrencyConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 202 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AllocatedProvisionedConcurrentExecutions: import_smithy_client.expectInt32,
    AvailableProvisionedConcurrentExecutions: import_smithy_client.expectInt32,
    LastModified: import_smithy_client.expectString,
    RequestedProvisionedConcurrentExecutions: import_smithy_client.expectInt32,
    Status: import_smithy_client.expectString,
    StatusReason: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_PutProvisionedConcurrencyConfigCommand");
var de_PutRuntimeManagementConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    FunctionArn: import_smithy_client.expectString,
    RuntimeVersionArn: import_smithy_client.expectString,
    UpdateRuntimeOn: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_PutRuntimeManagementConfigCommand");
var de_RemoveLayerVersionPermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_RemoveLayerVersionPermissionCommand");
var de_RemovePermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_RemovePermissionCommand");
var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_TagResourceCommand");
var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_UntagResourceCommand");
var de_UpdateAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AliasArn: import_smithy_client.expectString,
    Description: import_smithy_client.expectString,
    FunctionVersion: import_smithy_client.expectString,
    Name: import_smithy_client.expectString,
    RevisionId: import_smithy_client.expectString,
    RoutingConfig: /* @__PURE__ */ __name((_) => de_AliasRoutingConfiguration(_, context), "RoutingConfig")
  });
  Object.assign(contents, doc);
  return contents;
}, "de_UpdateAliasCommand");
var de_UpdateCodeSigningConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    CodeSigningConfig: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_UpdateCodeSigningConfigCommand");
var de_UpdateEventSourceMappingCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 202 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AmazonManagedKafkaEventSourceConfig: import_smithy_client._json,
    BatchSize: import_smithy_client.expectInt32,
    BisectBatchOnFunctionError: import_smithy_client.expectBoolean,
    DestinationConfig: import_smithy_client._json,
    DocumentDBEventSourceConfig: import_smithy_client._json,
    EventSourceArn: import_smithy_client.expectString,
    EventSourceMappingArn: import_smithy_client.expectString,
    FilterCriteria: import_smithy_client._json,
    FilterCriteriaError: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    FunctionResponseTypes: import_smithy_client._json,
    KMSKeyArn: import_smithy_client.expectString,
    LastModified: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastModified"),
    LastProcessingResult: import_smithy_client.expectString,
    MaximumBatchingWindowInSeconds: import_smithy_client.expectInt32,
    MaximumRecordAgeInSeconds: import_smithy_client.expectInt32,
    MaximumRetryAttempts: import_smithy_client.expectInt32,
    MetricsConfig: import_smithy_client._json,
    ParallelizationFactor: import_smithy_client.expectInt32,
    ProvisionedPollerConfig: import_smithy_client._json,
    Queues: import_smithy_client._json,
    ScalingConfig: import_smithy_client._json,
    SelfManagedEventSource: import_smithy_client._json,
    SelfManagedKafkaEventSourceConfig: import_smithy_client._json,
    SourceAccessConfigurations: import_smithy_client._json,
    StartingPosition: import_smithy_client.expectString,
    StartingPositionTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "StartingPositionTimestamp"),
    State: import_smithy_client.expectString,
    StateTransitionReason: import_smithy_client.expectString,
    Topics: import_smithy_client._json,
    TumblingWindowInSeconds: import_smithy_client.expectInt32,
    UUID: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_UpdateEventSourceMappingCommand");
var de_UpdateFunctionCodeCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Architectures: import_smithy_client._json,
    CodeSha256: import_smithy_client.expectString,
    CodeSize: import_smithy_client.expectLong,
    DeadLetterConfig: import_smithy_client._json,
    Description: import_smithy_client.expectString,
    Environment: import_smithy_client._json,
    EphemeralStorage: import_smithy_client._json,
    FileSystemConfigs: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    FunctionName: import_smithy_client.expectString,
    Handler: import_smithy_client.expectString,
    ImageConfigResponse: import_smithy_client._json,
    KMSKeyArn: import_smithy_client.expectString,
    LastModified: import_smithy_client.expectString,
    LastUpdateStatus: import_smithy_client.expectString,
    LastUpdateStatusReason: import_smithy_client.expectString,
    LastUpdateStatusReasonCode: import_smithy_client.expectString,
    Layers: import_smithy_client._json,
    LoggingConfig: import_smithy_client._json,
    MasterArn: import_smithy_client.expectString,
    MemorySize: import_smithy_client.expectInt32,
    PackageType: import_smithy_client.expectString,
    RevisionId: import_smithy_client.expectString,
    Role: import_smithy_client.expectString,
    Runtime: import_smithy_client.expectString,
    RuntimeVersionConfig: import_smithy_client._json,
    SigningJobArn: import_smithy_client.expectString,
    SigningProfileVersionArn: import_smithy_client.expectString,
    SnapStart: import_smithy_client._json,
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString,
    StateReasonCode: import_smithy_client.expectString,
    Timeout: import_smithy_client.expectInt32,
    TracingConfig: import_smithy_client._json,
    Version: import_smithy_client.expectString,
    VpcConfig: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_UpdateFunctionCodeCommand");
var de_UpdateFunctionConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Architectures: import_smithy_client._json,
    CodeSha256: import_smithy_client.expectString,
    CodeSize: import_smithy_client.expectLong,
    DeadLetterConfig: import_smithy_client._json,
    Description: import_smithy_client.expectString,
    Environment: import_smithy_client._json,
    EphemeralStorage: import_smithy_client._json,
    FileSystemConfigs: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    FunctionName: import_smithy_client.expectString,
    Handler: import_smithy_client.expectString,
    ImageConfigResponse: import_smithy_client._json,
    KMSKeyArn: import_smithy_client.expectString,
    LastModified: import_smithy_client.expectString,
    LastUpdateStatus: import_smithy_client.expectString,
    LastUpdateStatusReason: import_smithy_client.expectString,
    LastUpdateStatusReasonCode: import_smithy_client.expectString,
    Layers: import_smithy_client._json,
    LoggingConfig: import_smithy_client._json,
    MasterArn: import_smithy_client.expectString,
    MemorySize: import_smithy_client.expectInt32,
    PackageType: import_smithy_client.expectString,
    RevisionId: import_smithy_client.expectString,
    Role: import_smithy_client.expectString,
    Runtime: import_smithy_client.expectString,
    RuntimeVersionConfig: import_smithy_client._json,
    SigningJobArn: import_smithy_client.expectString,
    SigningProfileVersionArn: import_smithy_client.expectString,
    SnapStart: import_smithy_client._json,
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString,
    StateReasonCode: import_smithy_client.expectString,
    Timeout: import_smithy_client.expectInt32,
    TracingConfig: import_smithy_client._json,
    Version: import_smithy_client.expectString,
    VpcConfig: import_smithy_client._json
  });
  Object.assign(contents, doc);
  return contents;
}, "de_UpdateFunctionConfigurationCommand");
var de_UpdateFunctionEventInvokeConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    DestinationConfig: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    LastModified: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastModified"),
    MaximumEventAgeInSeconds: import_smithy_client.expectInt32,
    MaximumRetryAttempts: import_smithy_client.expectInt32
  });
  Object.assign(contents, doc);
  return contents;
}, "de_UpdateFunctionEventInvokeConfigCommand");
var de_UpdateFunctionUrlConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    AuthType: import_smithy_client.expectString,
    Cors: import_smithy_client._json,
    CreationTime: import_smithy_client.expectString,
    FunctionArn: import_smithy_client.expectString,
    FunctionUrl: import_smithy_client.expectString,
    InvokeMode: import_smithy_client.expectString,
    LastModifiedTime: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  return contents;
}, "de_UpdateFunctionUrlConfigCommand");
var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
  const parsedOutput = {
    ...output,
    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
  };
  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
  switch (errorCode) {
    case "InvalidParameterValueException":
    case "com.amazonaws.lambda#InvalidParameterValueException":
      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
    case "PolicyLengthExceededException":
    case "com.amazonaws.lambda#PolicyLengthExceededException":
      throw await de_PolicyLengthExceededExceptionRes(parsedOutput, context);
    case "PreconditionFailedException":
    case "com.amazonaws.lambda#PreconditionFailedException":
      throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
    case "ResourceConflictException":
    case "com.amazonaws.lambda#ResourceConflictException":
      throw await de_ResourceConflictExceptionRes(parsedOutput, context);
    case "ResourceNotFoundException":
    case "com.amazonaws.lambda#ResourceNotFoundException":
      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
    case "ServiceException":
    case "com.amazonaws.lambda#ServiceException":
      throw await de_ServiceExceptionRes(parsedOutput, context);
    case "TooManyRequestsException":
    case "com.amazonaws.lambda#TooManyRequestsException":
      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
    case "CodeSigningConfigNotFoundException":
    case "com.amazonaws.lambda#CodeSigningConfigNotFoundException":
      throw await de_CodeSigningConfigNotFoundExceptionRes(parsedOutput, context);
    case "CodeStorageExceededException":
    case "com.amazonaws.lambda#CodeStorageExceededException":
      throw await de_CodeStorageExceededExceptionRes(parsedOutput, context);
    case "CodeVerificationFailedException":
    case "com.amazonaws.lambda#CodeVerificationFailedException":
      throw await de_CodeVerificationFailedExceptionRes(parsedOutput, context);
    case "InvalidCodeSignatureException":
    case "com.amazonaws.lambda#InvalidCodeSignatureException":
      throw await de_InvalidCodeSignatureExceptionRes(parsedOutput, context);
    case "ResourceInUseException":
    case "com.amazonaws.lambda#ResourceInUseException":
      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
    case "ProvisionedConcurrencyConfigNotFoundException":
    case "com.amazonaws.lambda#ProvisionedConcurrencyConfigNotFoundException":
      throw await de_ProvisionedConcurrencyConfigNotFoundExceptionRes(parsedOutput, context);
    case "EC2AccessDeniedException":
    case "com.amazonaws.lambda#EC2AccessDeniedException":
      throw await de_EC2AccessDeniedExceptionRes(parsedOutput, context);
    case "EC2ThrottledException":
    case "com.amazonaws.lambda#EC2ThrottledException":
      throw await de_EC2ThrottledExceptionRes(parsedOutput, context);
    case "EC2UnexpectedException":
    case "com.amazonaws.lambda#EC2UnexpectedException":
      throw await de_EC2UnexpectedExceptionRes(parsedOutput, context);
    case "EFSIOException":
    case "com.amazonaws.lambda#EFSIOException":
      throw await de_EFSIOExceptionRes(parsedOutput, context);
    case "EFSMountConnectivityException":
    case "com.amazonaws.lambda#EFSMountConnectivityException":
      throw await de_EFSMountConnectivityExceptionRes(parsedOutput, context);
    case "EFSMountFailureException":
    case "com.amazonaws.lambda#EFSMountFailureException":
      throw await de_EFSMountFailureExceptionRes(parsedOutput, context);
    case "EFSMountTimeoutException":
    case "com.amazonaws.lambda#EFSMountTimeoutException":
      throw await de_EFSMountTimeoutExceptionRes(parsedOutput, context);
    case "ENILimitReachedException":
    case "com.amazonaws.lambda#ENILimitReachedException":
      throw await de_ENILimitReachedExceptionRes(parsedOutput, context);
    case "InvalidRequestContentException":
    case "com.amazonaws.lambda#InvalidRequestContentException":
      throw await de_InvalidRequestContentExceptionRes(parsedOutput, context);
    case "InvalidRuntimeException":
    case "com.amazonaws.lambda#InvalidRuntimeException":
      throw await de_InvalidRuntimeExceptionRes(parsedOutput, context);
    case "InvalidSecurityGroupIDException":
    case "com.amazonaws.lambda#InvalidSecurityGroupIDException":
      throw await de_InvalidSecurityGroupIDExceptionRes(parsedOutput, context);
    case "InvalidSubnetIDException":
    case "com.amazonaws.lambda#InvalidSubnetIDException":
      throw await de_InvalidSubnetIDExceptionRes(parsedOutput, context);
    case "InvalidZipFileException":
    case "com.amazonaws.lambda#InvalidZipFileException":
      throw await de_InvalidZipFileExceptionRes(parsedOutput, context);
    case "KMSAccessDeniedException":
    case "com.amazonaws.lambda#KMSAccessDeniedException":
      throw await de_KMSAccessDeniedExceptionRes(parsedOutput, context);
    case "KMSDisabledException":
    case "com.amazonaws.lambda#KMSDisabledException":
      throw await de_KMSDisabledExceptionRes(parsedOutput, context);
    case "KMSInvalidStateException":
    case "com.amazonaws.lambda#KMSInvalidStateException":
      throw await de_KMSInvalidStateExceptionRes(parsedOutput, context);
    case "KMSNotFoundException":
    case "com.amazonaws.lambda#KMSNotFoundException":
      throw await de_KMSNotFoundExceptionRes(parsedOutput, context);
    case "RecursiveInvocationException":
    case "com.amazonaws.lambda#RecursiveInvocationException":
      throw await de_RecursiveInvocationExceptionRes(parsedOutput, context);
    case "RequestTooLargeException":
    case "com.amazonaws.lambda#RequestTooLargeException":
      throw await de_RequestTooLargeExceptionRes(parsedOutput, context);
    case "ResourceNotReadyException":
    case "com.amazonaws.lambda#ResourceNotReadyException":
      throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
    case "SnapStartException":
    case "com.amazonaws.lambda#SnapStartException":
      throw await de_SnapStartExceptionRes(parsedOutput, context);
    case "SnapStartNotReadyException":
    case "com.amazonaws.lambda#SnapStartNotReadyException":
      throw await de_SnapStartNotReadyExceptionRes(parsedOutput, context);
    case "SnapStartTimeoutException":
    case "com.amazonaws.lambda#SnapStartTimeoutException":
      throw await de_SnapStartTimeoutExceptionRes(parsedOutput, context);
    case "SubnetIPAddressLimitReachedException":
    case "com.amazonaws.lambda#SubnetIPAddressLimitReachedException":
      throw await de_SubnetIPAddressLimitReachedExceptionRes(parsedOutput, context);
    case "UnsupportedMediaTypeException":
    case "com.amazonaws.lambda#UnsupportedMediaTypeException":
      throw await de_UnsupportedMediaTypeExceptionRes(parsedOutput, context);
    default:
      const parsedBody = parsedOutput.body;
      return throwDefaultError({
        output,
        parsedBody,
        errorCode
      });
  }
}, "de_CommandError");
var throwDefaultError = (0, import_smithy_client.withBaseException)(LambdaServiceException);
var de_CodeSigningConfigNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new CodeSigningConfigNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_CodeSigningConfigNotFoundExceptionRes");
var de_CodeStorageExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Type: import_smithy_client.expectString,
    message: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new CodeStorageExceededException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_CodeStorageExceededExceptionRes");
var de_CodeVerificationFailedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new CodeVerificationFailedException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_CodeVerificationFailedExceptionRes");
var de_EC2AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new EC2AccessDeniedException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_EC2AccessDeniedExceptionRes");
var de_EC2ThrottledExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new EC2ThrottledException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_EC2ThrottledExceptionRes");
var de_EC2UnexpectedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    EC2ErrorCode: import_smithy_client.expectString,
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new EC2UnexpectedException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_EC2UnexpectedExceptionRes");
var de_EFSIOExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new EFSIOException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_EFSIOExceptionRes");
var de_EFSMountConnectivityExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new EFSMountConnectivityException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_EFSMountConnectivityExceptionRes");
var de_EFSMountFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new EFSMountFailureException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_EFSMountFailureExceptionRes");
var de_EFSMountTimeoutExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new EFSMountTimeoutException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_EFSMountTimeoutExceptionRes");
var de_ENILimitReachedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new ENILimitReachedException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_ENILimitReachedExceptionRes");
var de_InvalidCodeSignatureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new InvalidCodeSignatureException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_InvalidCodeSignatureExceptionRes");
var de_InvalidParameterValueExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Type: import_smithy_client.expectString,
    message: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new InvalidParameterValueException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_InvalidParameterValueExceptionRes");
var de_InvalidRequestContentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Type: import_smithy_client.expectString,
    message: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new InvalidRequestContentException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_InvalidRequestContentExceptionRes");
var de_InvalidRuntimeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new InvalidRuntimeException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_InvalidRuntimeExceptionRes");
var de_InvalidSecurityGroupIDExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new InvalidSecurityGroupIDException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_InvalidSecurityGroupIDExceptionRes");
var de_InvalidSubnetIDExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new InvalidSubnetIDException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_InvalidSubnetIDExceptionRes");
var de_InvalidZipFileExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new InvalidZipFileException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_InvalidZipFileExceptionRes");
var de_KMSAccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new KMSAccessDeniedException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_KMSAccessDeniedExceptionRes");
var de_KMSDisabledExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new KMSDisabledException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_KMSDisabledExceptionRes");
var de_KMSInvalidStateExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new KMSInvalidStateException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_KMSInvalidStateExceptionRes");
var de_KMSNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new KMSNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_KMSNotFoundExceptionRes");
var de_PolicyLengthExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Type: import_smithy_client.expectString,
    message: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new PolicyLengthExceededException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_PolicyLengthExceededExceptionRes");
var de_PreconditionFailedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Type: import_smithy_client.expectString,
    message: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new PreconditionFailedException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_PreconditionFailedExceptionRes");
var de_ProvisionedConcurrencyConfigNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Type: import_smithy_client.expectString,
    message: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new ProvisionedConcurrencyConfigNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_ProvisionedConcurrencyConfigNotFoundExceptionRes");
var de_RecursiveInvocationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new RecursiveInvocationException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_RecursiveInvocationExceptionRes");
var de_RequestTooLargeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Type: import_smithy_client.expectString,
    message: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new RequestTooLargeException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_RequestTooLargeExceptionRes");
var de_ResourceConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Type: import_smithy_client.expectString,
    message: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new ResourceConflictException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_ResourceConflictExceptionRes");
var de_ResourceInUseExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new ResourceInUseException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_ResourceInUseExceptionRes");
var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new ResourceNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_ResourceNotFoundExceptionRes");
var de_ResourceNotReadyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Type: import_smithy_client.expectString,
    message: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new ResourceNotReadyException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_ResourceNotReadyExceptionRes");
var de_ServiceExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new ServiceException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_ServiceExceptionRes");
var de_SnapStartExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new SnapStartException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_SnapStartExceptionRes");
var de_SnapStartNotReadyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new SnapStartNotReadyException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_SnapStartNotReadyExceptionRes");
var de_SnapStartTimeoutExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new SnapStartTimeoutException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_SnapStartTimeoutExceptionRes");
var de_SubnetIPAddressLimitReachedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Message: import_smithy_client.expectString,
    Type: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new SubnetIPAddressLimitReachedException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_SubnetIPAddressLimitReachedExceptionRes");
var de_TooManyRequestsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({
    [_rAS]: [, parsedOutput.headers[_ra]]
  });
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Reason: import_smithy_client.expectString,
    Type: import_smithy_client.expectString,
    message: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new TooManyRequestsException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_TooManyRequestsExceptionRes");
var de_UnsupportedMediaTypeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const contents = (0, import_smithy_client.map)({});
  const data = parsedOutput.body;
  const doc = (0, import_smithy_client.take)(data, {
    Type: import_smithy_client.expectString,
    message: import_smithy_client.expectString
  });
  Object.assign(contents, doc);
  const exception = new UnsupportedMediaTypeException({
    $metadata: deserializeMetadata(parsedOutput),
    ...contents
  });
  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
}, "de_UnsupportedMediaTypeExceptionRes");
var de_InvokeWithResponseStreamResponseEvent = /* @__PURE__ */ __name((output, context) => {
  return context.eventStreamMarshaller.deserialize(output, async (event) => {
    if (event["PayloadChunk"] != null) {
      return {
        PayloadChunk: await de_InvokeResponseStreamUpdate_event(event["PayloadChunk"], context)
      };
    }
    if (event["InvokeComplete"] != null) {
      return {
        InvokeComplete: await de_InvokeWithResponseStreamCompleteEvent_event(event["InvokeComplete"], context)
      };
    }
    return { $unknown: event };
  });
}, "de_InvokeWithResponseStreamResponseEvent");
var de_InvokeResponseStreamUpdate_event = /* @__PURE__ */ __name(async (output, context) => {
  const contents = {};
  contents.Payload = output.body;
  return contents;
}, "de_InvokeResponseStreamUpdate_event");
var de_InvokeWithResponseStreamCompleteEvent_event = /* @__PURE__ */ __name(async (output, context) => {
  const contents = {};
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  Object.assign(contents, (0, import_smithy_client._json)(data));
  return contents;
}, "de_InvokeWithResponseStreamCompleteEvent_event");
var se_AdditionalVersionWeights = /* @__PURE__ */ __name((input, context) => {
  return Object.entries(input).reduce((acc, [key, value]) => {
    if (value === null) {
      return acc;
    }
    acc[key] = (0, import_smithy_client.serializeFloat)(value);
    return acc;
  }, {});
}, "se_AdditionalVersionWeights");
var se_AliasRoutingConfiguration = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    AdditionalVersionWeights: /* @__PURE__ */ __name((_) => se_AdditionalVersionWeights(_, context), "AdditionalVersionWeights")
  });
}, "se_AliasRoutingConfiguration");
var se_FunctionCode = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    ImageUri: [],
    S3Bucket: [],
    S3Key: [],
    S3ObjectVersion: [],
    SourceKMSKeyArn: [],
    ZipFile: context.base64Encoder
  });
}, "se_FunctionCode");
var se_LayerVersionContentInput = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    S3Bucket: [],
    S3Key: [],
    S3ObjectVersion: [],
    ZipFile: context.base64Encoder
  });
}, "se_LayerVersionContentInput");
var de_AdditionalVersionWeights = /* @__PURE__ */ __name((output, context) => {
  return Object.entries(output).reduce((acc, [key, value]) => {
    if (value === null) {
      return acc;
    }
    acc[key] = (0, import_smithy_client.limitedParseDouble)(value);
    return acc;
  }, {});
}, "de_AdditionalVersionWeights");
var de_AliasConfiguration = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    AliasArn: import_smithy_client.expectString,
    Description: import_smithy_client.expectString,
    FunctionVersion: import_smithy_client.expectString,
    Name: import_smithy_client.expectString,
    RevisionId: import_smithy_client.expectString,
    RoutingConfig: /* @__PURE__ */ __name((_) => de_AliasRoutingConfiguration(_, context), "RoutingConfig")
  });
}, "de_AliasConfiguration");
var de_AliasList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_AliasConfiguration(entry, context);
  });
  return retVal;
}, "de_AliasList");
var de_AliasRoutingConfiguration = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    AdditionalVersionWeights: /* @__PURE__ */ __name((_) => de_AdditionalVersionWeights(_, context), "AdditionalVersionWeights")
  });
}, "de_AliasRoutingConfiguration");
var de_EventSourceMappingConfiguration = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    AmazonManagedKafkaEventSourceConfig: import_smithy_client._json,
    BatchSize: import_smithy_client.expectInt32,
    BisectBatchOnFunctionError: import_smithy_client.expectBoolean,
    DestinationConfig: import_smithy_client._json,
    DocumentDBEventSourceConfig: import_smithy_client._json,
    EventSourceArn: import_smithy_client.expectString,
    EventSourceMappingArn: import_smithy_client.expectString,
    FilterCriteria: import_smithy_client._json,
    FilterCriteriaError: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    FunctionResponseTypes: import_smithy_client._json,
    KMSKeyArn: import_smithy_client.expectString,
    LastModified: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastModified"),
    LastProcessingResult: import_smithy_client.expectString,
    MaximumBatchingWindowInSeconds: import_smithy_client.expectInt32,
    MaximumRecordAgeInSeconds: import_smithy_client.expectInt32,
    MaximumRetryAttempts: import_smithy_client.expectInt32,
    MetricsConfig: import_smithy_client._json,
    ParallelizationFactor: import_smithy_client.expectInt32,
    ProvisionedPollerConfig: import_smithy_client._json,
    Queues: import_smithy_client._json,
    ScalingConfig: import_smithy_client._json,
    SelfManagedEventSource: import_smithy_client._json,
    SelfManagedKafkaEventSourceConfig: import_smithy_client._json,
    SourceAccessConfigurations: import_smithy_client._json,
    StartingPosition: import_smithy_client.expectString,
    StartingPositionTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "StartingPositionTimestamp"),
    State: import_smithy_client.expectString,
    StateTransitionReason: import_smithy_client.expectString,
    Topics: import_smithy_client._json,
    TumblingWindowInSeconds: import_smithy_client.expectInt32,
    UUID: import_smithy_client.expectString
  });
}, "de_EventSourceMappingConfiguration");
var de_EventSourceMappingsList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_EventSourceMappingConfiguration(entry, context);
  });
  return retVal;
}, "de_EventSourceMappingsList");
var de_FunctionEventInvokeConfig = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    DestinationConfig: import_smithy_client._json,
    FunctionArn: import_smithy_client.expectString,
    LastModified: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastModified"),
    MaximumEventAgeInSeconds: import_smithy_client.expectInt32,
    MaximumRetryAttempts: import_smithy_client.expectInt32
  });
}, "de_FunctionEventInvokeConfig");
var de_FunctionEventInvokeConfigList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_FunctionEventInvokeConfig(entry, context);
  });
  return retVal;
}, "de_FunctionEventInvokeConfigList");
var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
  httpStatusCode: output.statusCode,
  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
  extendedRequestId: output.headers["x-amz-id-2"],
  cfId: output.headers["x-amz-cf-id"]
}), "deserializeMetadata");
var _A = "Arn";
var _CA = "CompatibleArchitecture";
var _CC = "ClientContext";
var _CR = "CompatibleRuntime";
var _ESA = "EventSourceArn";
var _EV = "ExecutedVersion";
var _FE = "FunctionError";
var _FN = "FunctionName";
var _FV = "FunctionVersion";
var _IT = "InvocationType";
var _L = "List";
var _LR = "LogResult";
var _LT = "LogType";
var _M = "Marker";
var _MI = "MaxItems";
var _MR = "MasterRegion";
var _Q = "Qualifier";
var _RI = "RevisionId";
var _RSCT = "ResponseStreamContentType";
var _TK = "TagKeys";
var _ct = "content-type";
var _f = "find";
var _rAS = "retryAfterSeconds";
var _ra = "retry-after";
var _tK = "tagKeys";
var _xacc = "x-amz-client-context";
var _xaev = "x-amz-executed-version";
var _xafe = "x-amz-function-error";
var _xait = "x-amz-invocation-type";
var _xalr = "x-amz-log-result";
var _xalt = "x-amz-log-type";

// src/commands/AddLayerVersionPermissionCommand.ts
var AddLayerVersionPermissionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "AddLayerVersionPermission", {}).n("LambdaClient", "AddLayerVersionPermissionCommand").f(void 0, void 0).ser(se_AddLayerVersionPermissionCommand).de(de_AddLayerVersionPermissionCommand).build() {
  static {
    __name(this, "AddLayerVersionPermissionCommand");
  }
};

// src/commands/AddPermissionCommand.ts



var AddPermissionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "AddPermission", {}).n("LambdaClient", "AddPermissionCommand").f(void 0, void 0).ser(se_AddPermissionCommand).de(de_AddPermissionCommand).build() {
  static {
    __name(this, "AddPermissionCommand");
  }
};

// src/commands/CreateAliasCommand.ts



var CreateAliasCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "CreateAlias", {}).n("LambdaClient", "CreateAliasCommand").f(void 0, void 0).ser(se_CreateAliasCommand).de(de_CreateAliasCommand).build() {
  static {
    __name(this, "CreateAliasCommand");
  }
};

// src/commands/CreateCodeSigningConfigCommand.ts



var CreateCodeSigningConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "CreateCodeSigningConfig", {}).n("LambdaClient", "CreateCodeSigningConfigCommand").f(void 0, void 0).ser(se_CreateCodeSigningConfigCommand).de(de_CreateCodeSigningConfigCommand).build() {
  static {
    __name(this, "CreateCodeSigningConfigCommand");
  }
};

// src/commands/CreateEventSourceMappingCommand.ts



var CreateEventSourceMappingCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "CreateEventSourceMapping", {}).n("LambdaClient", "CreateEventSourceMappingCommand").f(void 0, void 0).ser(se_CreateEventSourceMappingCommand).de(de_CreateEventSourceMappingCommand).build() {
  static {
    __name(this, "CreateEventSourceMappingCommand");
  }
};

// src/commands/CreateFunctionCommand.ts



var CreateFunctionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "CreateFunction", {}).n("LambdaClient", "CreateFunctionCommand").f(CreateFunctionRequestFilterSensitiveLog, FunctionConfigurationFilterSensitiveLog).ser(se_CreateFunctionCommand).de(de_CreateFunctionCommand).build() {
  static {
    __name(this, "CreateFunctionCommand");
  }
};

// src/commands/CreateFunctionUrlConfigCommand.ts



var CreateFunctionUrlConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "CreateFunctionUrlConfig", {}).n("LambdaClient", "CreateFunctionUrlConfigCommand").f(void 0, void 0).ser(se_CreateFunctionUrlConfigCommand).de(de_CreateFunctionUrlConfigCommand).build() {
  static {
    __name(this, "CreateFunctionUrlConfigCommand");
  }
};

// src/commands/DeleteAliasCommand.ts



var DeleteAliasCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "DeleteAlias", {}).n("LambdaClient", "DeleteAliasCommand").f(void 0, void 0).ser(se_DeleteAliasCommand).de(de_DeleteAliasCommand).build() {
  static {
    __name(this, "DeleteAliasCommand");
  }
};

// src/commands/DeleteCodeSigningConfigCommand.ts



var DeleteCodeSigningConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "DeleteCodeSigningConfig", {}).n("LambdaClient", "DeleteCodeSigningConfigCommand").f(void 0, void 0).ser(se_DeleteCodeSigningConfigCommand).de(de_DeleteCodeSigningConfigCommand).build() {
  static {
    __name(this, "DeleteCodeSigningConfigCommand");
  }
};

// src/commands/DeleteEventSourceMappingCommand.ts



var DeleteEventSourceMappingCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "DeleteEventSourceMapping", {}).n("LambdaClient", "DeleteEventSourceMappingCommand").f(void 0, void 0).ser(se_DeleteEventSourceMappingCommand).de(de_DeleteEventSourceMappingCommand).build() {
  static {
    __name(this, "DeleteEventSourceMappingCommand");
  }
};

// src/commands/DeleteFunctionCodeSigningConfigCommand.ts



var DeleteFunctionCodeSigningConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "DeleteFunctionCodeSigningConfig", {}).n("LambdaClient", "DeleteFunctionCodeSigningConfigCommand").f(void 0, void 0).ser(se_DeleteFunctionCodeSigningConfigCommand).de(de_DeleteFunctionCodeSigningConfigCommand).build() {
  static {
    __name(this, "DeleteFunctionCodeSigningConfigCommand");
  }
};

// src/commands/DeleteFunctionCommand.ts



var DeleteFunctionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "DeleteFunction", {}).n("LambdaClient", "DeleteFunctionCommand").f(void 0, void 0).ser(se_DeleteFunctionCommand).de(de_DeleteFunctionCommand).build() {
  static {
    __name(this, "DeleteFunctionCommand");
  }
};

// src/commands/DeleteFunctionConcurrencyCommand.ts



var DeleteFunctionConcurrencyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "DeleteFunctionConcurrency", {}).n("LambdaClient", "DeleteFunctionConcurrencyCommand").f(void 0, void 0).ser(se_DeleteFunctionConcurrencyCommand).de(de_DeleteFunctionConcurrencyCommand).build() {
  static {
    __name(this, "DeleteFunctionConcurrencyCommand");
  }
};

// src/commands/DeleteFunctionEventInvokeConfigCommand.ts



var DeleteFunctionEventInvokeConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "DeleteFunctionEventInvokeConfig", {}).n("LambdaClient", "DeleteFunctionEventInvokeConfigCommand").f(void 0, void 0).ser(se_DeleteFunctionEventInvokeConfigCommand).de(de_DeleteFunctionEventInvokeConfigCommand).build() {
  static {
    __name(this, "DeleteFunctionEventInvokeConfigCommand");
  }
};

// src/commands/DeleteFunctionUrlConfigCommand.ts



var DeleteFunctionUrlConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "DeleteFunctionUrlConfig", {}).n("LambdaClient", "DeleteFunctionUrlConfigCommand").f(void 0, void 0).ser(se_DeleteFunctionUrlConfigCommand).de(de_DeleteFunctionUrlConfigCommand).build() {
  static {
    __name(this, "DeleteFunctionUrlConfigCommand");
  }
};

// src/commands/DeleteLayerVersionCommand.ts



var DeleteLayerVersionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "DeleteLayerVersion", {}).n("LambdaClient", "DeleteLayerVersionCommand").f(void 0, void 0).ser(se_DeleteLayerVersionCommand).de(de_DeleteLayerVersionCommand).build() {
  static {
    __name(this, "DeleteLayerVersionCommand");
  }
};

// src/commands/DeleteProvisionedConcurrencyConfigCommand.ts



var DeleteProvisionedConcurrencyConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "DeleteProvisionedConcurrencyConfig", {}).n("LambdaClient", "DeleteProvisionedConcurrencyConfigCommand").f(void 0, void 0).ser(se_DeleteProvisionedConcurrencyConfigCommand).de(de_DeleteProvisionedConcurrencyConfigCommand).build() {
  static {
    __name(this, "DeleteProvisionedConcurrencyConfigCommand");
  }
};

// src/commands/GetAccountSettingsCommand.ts



var GetAccountSettingsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetAccountSettings", {}).n("LambdaClient", "GetAccountSettingsCommand").f(void 0, void 0).ser(se_GetAccountSettingsCommand).de(de_GetAccountSettingsCommand).build() {
  static {
    __name(this, "GetAccountSettingsCommand");
  }
};

// src/commands/GetAliasCommand.ts



var GetAliasCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetAlias", {}).n("LambdaClient", "GetAliasCommand").f(void 0, void 0).ser(se_GetAliasCommand).de(de_GetAliasCommand).build() {
  static {
    __name(this, "GetAliasCommand");
  }
};

// src/commands/GetCodeSigningConfigCommand.ts



var GetCodeSigningConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetCodeSigningConfig", {}).n("LambdaClient", "GetCodeSigningConfigCommand").f(void 0, void 0).ser(se_GetCodeSigningConfigCommand).de(de_GetCodeSigningConfigCommand).build() {
  static {
    __name(this, "GetCodeSigningConfigCommand");
  }
};

// src/commands/GetEventSourceMappingCommand.ts



var GetEventSourceMappingCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetEventSourceMapping", {}).n("LambdaClient", "GetEventSourceMappingCommand").f(void 0, void 0).ser(se_GetEventSourceMappingCommand).de(de_GetEventSourceMappingCommand).build() {
  static {
    __name(this, "GetEventSourceMappingCommand");
  }
};

// src/commands/GetFunctionCodeSigningConfigCommand.ts



var GetFunctionCodeSigningConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetFunctionCodeSigningConfig", {}).n("LambdaClient", "GetFunctionCodeSigningConfigCommand").f(void 0, void 0).ser(se_GetFunctionCodeSigningConfigCommand).de(de_GetFunctionCodeSigningConfigCommand).build() {
  static {
    __name(this, "GetFunctionCodeSigningConfigCommand");
  }
};

// src/commands/GetFunctionCommand.ts



var GetFunctionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetFunction", {}).n("LambdaClient", "GetFunctionCommand").f(void 0, GetFunctionResponseFilterSensitiveLog).ser(se_GetFunctionCommand).de(de_GetFunctionCommand).build() {
  static {
    __name(this, "GetFunctionCommand");
  }
};

// src/commands/GetFunctionConcurrencyCommand.ts



var GetFunctionConcurrencyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetFunctionConcurrency", {}).n("LambdaClient", "GetFunctionConcurrencyCommand").f(void 0, void 0).ser(se_GetFunctionConcurrencyCommand).de(de_GetFunctionConcurrencyCommand).build() {
  static {
    __name(this, "GetFunctionConcurrencyCommand");
  }
};

// src/commands/GetFunctionConfigurationCommand.ts



var GetFunctionConfigurationCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetFunctionConfiguration", {}).n("LambdaClient", "GetFunctionConfigurationCommand").f(void 0, FunctionConfigurationFilterSensitiveLog).ser(se_GetFunctionConfigurationCommand).de(de_GetFunctionConfigurationCommand).build() {
  static {
    __name(this, "GetFunctionConfigurationCommand");
  }
};

// src/commands/GetFunctionEventInvokeConfigCommand.ts



var GetFunctionEventInvokeConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetFunctionEventInvokeConfig", {}).n("LambdaClient", "GetFunctionEventInvokeConfigCommand").f(void 0, void 0).ser(se_GetFunctionEventInvokeConfigCommand).de(de_GetFunctionEventInvokeConfigCommand).build() {
  static {
    __name(this, "GetFunctionEventInvokeConfigCommand");
  }
};

// src/commands/GetFunctionRecursionConfigCommand.ts



var GetFunctionRecursionConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetFunctionRecursionConfig", {}).n("LambdaClient", "GetFunctionRecursionConfigCommand").f(void 0, void 0).ser(se_GetFunctionRecursionConfigCommand).de(de_GetFunctionRecursionConfigCommand).build() {
  static {
    __name(this, "GetFunctionRecursionConfigCommand");
  }
};

// src/commands/GetFunctionUrlConfigCommand.ts



var GetFunctionUrlConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetFunctionUrlConfig", {}).n("LambdaClient", "GetFunctionUrlConfigCommand").f(void 0, void 0).ser(se_GetFunctionUrlConfigCommand).de(de_GetFunctionUrlConfigCommand).build() {
  static {
    __name(this, "GetFunctionUrlConfigCommand");
  }
};

// src/commands/GetLayerVersionByArnCommand.ts



var GetLayerVersionByArnCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetLayerVersionByArn", {}).n("LambdaClient", "GetLayerVersionByArnCommand").f(void 0, void 0).ser(se_GetLayerVersionByArnCommand).de(de_GetLayerVersionByArnCommand).build() {
  static {
    __name(this, "GetLayerVersionByArnCommand");
  }
};

// src/commands/GetLayerVersionCommand.ts



var GetLayerVersionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetLayerVersion", {}).n("LambdaClient", "GetLayerVersionCommand").f(void 0, void 0).ser(se_GetLayerVersionCommand).de(de_GetLayerVersionCommand).build() {
  static {
    __name(this, "GetLayerVersionCommand");
  }
};

// src/commands/GetLayerVersionPolicyCommand.ts



var GetLayerVersionPolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetLayerVersionPolicy", {}).n("LambdaClient", "GetLayerVersionPolicyCommand").f(void 0, void 0).ser(se_GetLayerVersionPolicyCommand).de(de_GetLayerVersionPolicyCommand).build() {
  static {
    __name(this, "GetLayerVersionPolicyCommand");
  }
};

// src/commands/GetPolicyCommand.ts



var GetPolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetPolicy", {}).n("LambdaClient", "GetPolicyCommand").f(void 0, void 0).ser(se_GetPolicyCommand).de(de_GetPolicyCommand).build() {
  static {
    __name(this, "GetPolicyCommand");
  }
};

// src/commands/GetProvisionedConcurrencyConfigCommand.ts



var GetProvisionedConcurrencyConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetProvisionedConcurrencyConfig", {}).n("LambdaClient", "GetProvisionedConcurrencyConfigCommand").f(void 0, void 0).ser(se_GetProvisionedConcurrencyConfigCommand).de(de_GetProvisionedConcurrencyConfigCommand).build() {
  static {
    __name(this, "GetProvisionedConcurrencyConfigCommand");
  }
};

// src/commands/GetRuntimeManagementConfigCommand.ts



var GetRuntimeManagementConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "GetRuntimeManagementConfig", {}).n("LambdaClient", "GetRuntimeManagementConfigCommand").f(void 0, void 0).ser(se_GetRuntimeManagementConfigCommand).de(de_GetRuntimeManagementConfigCommand).build() {
  static {
    __name(this, "GetRuntimeManagementConfigCommand");
  }
};

// src/commands/InvokeAsyncCommand.ts



var InvokeAsyncCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "InvokeAsync", {}).n("LambdaClient", "InvokeAsyncCommand").f(InvokeAsyncRequestFilterSensitiveLog, void 0).ser(se_InvokeAsyncCommand).de(de_InvokeAsyncCommand).build() {
  static {
    __name(this, "InvokeAsyncCommand");
  }
};

// src/commands/InvokeCommand.ts



var InvokeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "Invoke", {}).n("LambdaClient", "InvokeCommand").f(InvocationRequestFilterSensitiveLog, InvocationResponseFilterSensitiveLog).ser(se_InvokeCommand).de(de_InvokeCommand).build() {
  static {
    __name(this, "InvokeCommand");
  }
};

// src/commands/InvokeWithResponseStreamCommand.ts



var InvokeWithResponseStreamCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "InvokeWithResponseStream", {
  /**
   * @internal
   */
  eventStream: {
    output: true
  }
}).n("LambdaClient", "InvokeWithResponseStreamCommand").f(InvokeWithResponseStreamRequestFilterSensitiveLog, InvokeWithResponseStreamResponseFilterSensitiveLog).ser(se_InvokeWithResponseStreamCommand).de(de_InvokeWithResponseStreamCommand).build() {
  static {
    __name(this, "InvokeWithResponseStreamCommand");
  }
};

// src/commands/ListAliasesCommand.ts



var ListAliasesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListAliases", {}).n("LambdaClient", "ListAliasesCommand").f(void 0, void 0).ser(se_ListAliasesCommand).de(de_ListAliasesCommand).build() {
  static {
    __name(this, "ListAliasesCommand");
  }
};

// src/commands/ListCodeSigningConfigsCommand.ts



var ListCodeSigningConfigsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListCodeSigningConfigs", {}).n("LambdaClient", "ListCodeSigningConfigsCommand").f(void 0, void 0).ser(se_ListCodeSigningConfigsCommand).de(de_ListCodeSigningConfigsCommand).build() {
  static {
    __name(this, "ListCodeSigningConfigsCommand");
  }
};

// src/commands/ListEventSourceMappingsCommand.ts



var ListEventSourceMappingsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListEventSourceMappings", {}).n("LambdaClient", "ListEventSourceMappingsCommand").f(void 0, void 0).ser(se_ListEventSourceMappingsCommand).de(de_ListEventSourceMappingsCommand).build() {
  static {
    __name(this, "ListEventSourceMappingsCommand");
  }
};

// src/commands/ListFunctionEventInvokeConfigsCommand.ts



var ListFunctionEventInvokeConfigsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListFunctionEventInvokeConfigs", {}).n("LambdaClient", "ListFunctionEventInvokeConfigsCommand").f(void 0, void 0).ser(se_ListFunctionEventInvokeConfigsCommand).de(de_ListFunctionEventInvokeConfigsCommand).build() {
  static {
    __name(this, "ListFunctionEventInvokeConfigsCommand");
  }
};

// src/commands/ListFunctionsByCodeSigningConfigCommand.ts



var ListFunctionsByCodeSigningConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListFunctionsByCodeSigningConfig", {}).n("LambdaClient", "ListFunctionsByCodeSigningConfigCommand").f(void 0, void 0).ser(se_ListFunctionsByCodeSigningConfigCommand).de(de_ListFunctionsByCodeSigningConfigCommand).build() {
  static {
    __name(this, "ListFunctionsByCodeSigningConfigCommand");
  }
};

// src/commands/ListFunctionsCommand.ts



var ListFunctionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListFunctions", {}).n("LambdaClient", "ListFunctionsCommand").f(void 0, ListFunctionsResponseFilterSensitiveLog).ser(se_ListFunctionsCommand).de(de_ListFunctionsCommand).build() {
  static {
    __name(this, "ListFunctionsCommand");
  }
};

// src/commands/ListFunctionUrlConfigsCommand.ts



var ListFunctionUrlConfigsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListFunctionUrlConfigs", {}).n("LambdaClient", "ListFunctionUrlConfigsCommand").f(void 0, void 0).ser(se_ListFunctionUrlConfigsCommand).de(de_ListFunctionUrlConfigsCommand).build() {
  static {
    __name(this, "ListFunctionUrlConfigsCommand");
  }
};

// src/commands/ListLayersCommand.ts



var ListLayersCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListLayers", {}).n("LambdaClient", "ListLayersCommand").f(void 0, void 0).ser(se_ListLayersCommand).de(de_ListLayersCommand).build() {
  static {
    __name(this, "ListLayersCommand");
  }
};

// src/commands/ListLayerVersionsCommand.ts



var ListLayerVersionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListLayerVersions", {}).n("LambdaClient", "ListLayerVersionsCommand").f(void 0, void 0).ser(se_ListLayerVersionsCommand).de(de_ListLayerVersionsCommand).build() {
  static {
    __name(this, "ListLayerVersionsCommand");
  }
};

// src/commands/ListProvisionedConcurrencyConfigsCommand.ts



var ListProvisionedConcurrencyConfigsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListProvisionedConcurrencyConfigs", {}).n("LambdaClient", "ListProvisionedConcurrencyConfigsCommand").f(void 0, void 0).ser(se_ListProvisionedConcurrencyConfigsCommand).de(de_ListProvisionedConcurrencyConfigsCommand).build() {
  static {
    __name(this, "ListProvisionedConcurrencyConfigsCommand");
  }
};

// src/commands/ListTagsCommand.ts



var ListTagsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListTags", {}).n("LambdaClient", "ListTagsCommand").f(void 0, void 0).ser(se_ListTagsCommand).de(de_ListTagsCommand).build() {
  static {
    __name(this, "ListTagsCommand");
  }
};

// src/commands/ListVersionsByFunctionCommand.ts



var ListVersionsByFunctionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "ListVersionsByFunction", {}).n("LambdaClient", "ListVersionsByFunctionCommand").f(void 0, ListVersionsByFunctionResponseFilterSensitiveLog).ser(se_ListVersionsByFunctionCommand).de(de_ListVersionsByFunctionCommand).build() {
  static {
    __name(this, "ListVersionsByFunctionCommand");
  }
};

// src/commands/PublishLayerVersionCommand.ts



var PublishLayerVersionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "PublishLayerVersion", {}).n("LambdaClient", "PublishLayerVersionCommand").f(PublishLayerVersionRequestFilterSensitiveLog, void 0).ser(se_PublishLayerVersionCommand).de(de_PublishLayerVersionCommand).build() {
  static {
    __name(this, "PublishLayerVersionCommand");
  }
};

// src/commands/PublishVersionCommand.ts



var PublishVersionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "PublishVersion", {}).n("LambdaClient", "PublishVersionCommand").f(void 0, FunctionConfigurationFilterSensitiveLog).ser(se_PublishVersionCommand).de(de_PublishVersionCommand).build() {
  static {
    __name(this, "PublishVersionCommand");
  }
};

// src/commands/PutFunctionCodeSigningConfigCommand.ts



var PutFunctionCodeSigningConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "PutFunctionCodeSigningConfig", {}).n("LambdaClient", "PutFunctionCodeSigningConfigCommand").f(void 0, void 0).ser(se_PutFunctionCodeSigningConfigCommand).de(de_PutFunctionCodeSigningConfigCommand).build() {
  static {
    __name(this, "PutFunctionCodeSigningConfigCommand");
  }
};

// src/commands/PutFunctionConcurrencyCommand.ts



var PutFunctionConcurrencyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "PutFunctionConcurrency", {}).n("LambdaClient", "PutFunctionConcurrencyCommand").f(void 0, void 0).ser(se_PutFunctionConcurrencyCommand).de(de_PutFunctionConcurrencyCommand).build() {
  static {
    __name(this, "PutFunctionConcurrencyCommand");
  }
};

// src/commands/PutFunctionEventInvokeConfigCommand.ts



var PutFunctionEventInvokeConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "PutFunctionEventInvokeConfig", {}).n("LambdaClient", "PutFunctionEventInvokeConfigCommand").f(void 0, void 0).ser(se_PutFunctionEventInvokeConfigCommand).de(de_PutFunctionEventInvokeConfigCommand).build() {
  static {
    __name(this, "PutFunctionEventInvokeConfigCommand");
  }
};

// src/commands/PutFunctionRecursionConfigCommand.ts



var PutFunctionRecursionConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "PutFunctionRecursionConfig", {}).n("LambdaClient", "PutFunctionRecursionConfigCommand").f(void 0, void 0).ser(se_PutFunctionRecursionConfigCommand).de(de_PutFunctionRecursionConfigCommand).build() {
  static {
    __name(this, "PutFunctionRecursionConfigCommand");
  }
};

// src/commands/PutProvisionedConcurrencyConfigCommand.ts



var PutProvisionedConcurrencyConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "PutProvisionedConcurrencyConfig", {}).n("LambdaClient", "PutProvisionedConcurrencyConfigCommand").f(void 0, void 0).ser(se_PutProvisionedConcurrencyConfigCommand).de(de_PutProvisionedConcurrencyConfigCommand).build() {
  static {
    __name(this, "PutProvisionedConcurrencyConfigCommand");
  }
};

// src/commands/PutRuntimeManagementConfigCommand.ts



var PutRuntimeManagementConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "PutRuntimeManagementConfig", {}).n("LambdaClient", "PutRuntimeManagementConfigCommand").f(void 0, void 0).ser(se_PutRuntimeManagementConfigCommand).de(de_PutRuntimeManagementConfigCommand).build() {
  static {
    __name(this, "PutRuntimeManagementConfigCommand");
  }
};

// src/commands/RemoveLayerVersionPermissionCommand.ts



var RemoveLayerVersionPermissionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "RemoveLayerVersionPermission", {}).n("LambdaClient", "RemoveLayerVersionPermissionCommand").f(void 0, void 0).ser(se_RemoveLayerVersionPermissionCommand).de(de_RemoveLayerVersionPermissionCommand).build() {
  static {
    __name(this, "RemoveLayerVersionPermissionCommand");
  }
};

// src/commands/RemovePermissionCommand.ts



var RemovePermissionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "RemovePermission", {}).n("LambdaClient", "RemovePermissionCommand").f(void 0, void 0).ser(se_RemovePermissionCommand).de(de_RemovePermissionCommand).build() {
  static {
    __name(this, "RemovePermissionCommand");
  }
};

// src/commands/TagResourceCommand.ts



var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "TagResource", {}).n("LambdaClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
  static {
    __name(this, "TagResourceCommand");
  }
};

// src/commands/UntagResourceCommand.ts



var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "UntagResource", {}).n("LambdaClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
  static {
    __name(this, "UntagResourceCommand");
  }
};

// src/commands/UpdateAliasCommand.ts



var UpdateAliasCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "UpdateAlias", {}).n("LambdaClient", "UpdateAliasCommand").f(void 0, void 0).ser(se_UpdateAliasCommand).de(de_UpdateAliasCommand).build() {
  static {
    __name(this, "UpdateAliasCommand");
  }
};

// src/commands/UpdateCodeSigningConfigCommand.ts



var UpdateCodeSigningConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "UpdateCodeSigningConfig", {}).n("LambdaClient", "UpdateCodeSigningConfigCommand").f(void 0, void 0).ser(se_UpdateCodeSigningConfigCommand).de(de_UpdateCodeSigningConfigCommand).build() {
  static {
    __name(this, "UpdateCodeSigningConfigCommand");
  }
};

// src/commands/UpdateEventSourceMappingCommand.ts



var UpdateEventSourceMappingCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "UpdateEventSourceMapping", {}).n("LambdaClient", "UpdateEventSourceMappingCommand").f(void 0, void 0).ser(se_UpdateEventSourceMappingCommand).de(de_UpdateEventSourceMappingCommand).build() {
  static {
    __name(this, "UpdateEventSourceMappingCommand");
  }
};

// src/commands/UpdateFunctionCodeCommand.ts



var UpdateFunctionCodeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "UpdateFunctionCode", {}).n("LambdaClient", "UpdateFunctionCodeCommand").f(UpdateFunctionCodeRequestFilterSensitiveLog, FunctionConfigurationFilterSensitiveLog).ser(se_UpdateFunctionCodeCommand).de(de_UpdateFunctionCodeCommand).build() {
  static {
    __name(this, "UpdateFunctionCodeCommand");
  }
};

// src/commands/UpdateFunctionConfigurationCommand.ts



var UpdateFunctionConfigurationCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "UpdateFunctionConfiguration", {}).n("LambdaClient", "UpdateFunctionConfigurationCommand").f(UpdateFunctionConfigurationRequestFilterSensitiveLog, FunctionConfigurationFilterSensitiveLog).ser(se_UpdateFunctionConfigurationCommand).de(de_UpdateFunctionConfigurationCommand).build() {
  static {
    __name(this, "UpdateFunctionConfigurationCommand");
  }
};

// src/commands/UpdateFunctionEventInvokeConfigCommand.ts



var UpdateFunctionEventInvokeConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "UpdateFunctionEventInvokeConfig", {}).n("LambdaClient", "UpdateFunctionEventInvokeConfigCommand").f(void 0, void 0).ser(se_UpdateFunctionEventInvokeConfigCommand).de(de_UpdateFunctionEventInvokeConfigCommand).build() {
  static {
    __name(this, "UpdateFunctionEventInvokeConfigCommand");
  }
};

// src/commands/UpdateFunctionUrlConfigCommand.ts



var UpdateFunctionUrlConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSGirApiService", "UpdateFunctionUrlConfig", {}).n("LambdaClient", "UpdateFunctionUrlConfigCommand").f(void 0, void 0).ser(se_UpdateFunctionUrlConfigCommand).de(de_UpdateFunctionUrlConfigCommand).build() {
  static {
    __name(this, "UpdateFunctionUrlConfigCommand");
  }
};

// src/Lambda.ts
var commands = {
  AddLayerVersionPermissionCommand,
  AddPermissionCommand,
  CreateAliasCommand,
  CreateCodeSigningConfigCommand,
  CreateEventSourceMappingCommand,
  CreateFunctionCommand,
  CreateFunctionUrlConfigCommand,
  DeleteAliasCommand,
  DeleteCodeSigningConfigCommand,
  DeleteEventSourceMappingCommand,
  DeleteFunctionCommand,
  DeleteFunctionCodeSigningConfigCommand,
  DeleteFunctionConcurrencyCommand,
  DeleteFunctionEventInvokeConfigCommand,
  DeleteFunctionUrlConfigCommand,
  DeleteLayerVersionCommand,
  DeleteProvisionedConcurrencyConfigCommand,
  GetAccountSettingsCommand,
  GetAliasCommand,
  GetCodeSigningConfigCommand,
  GetEventSourceMappingCommand,
  GetFunctionCommand,
  GetFunctionCodeSigningConfigCommand,
  GetFunctionConcurrencyCommand,
  GetFunctionConfigurationCommand,
  GetFunctionEventInvokeConfigCommand,
  GetFunctionRecursionConfigCommand,
  GetFunctionUrlConfigCommand,
  GetLayerVersionCommand,
  GetLayerVersionByArnCommand,
  GetLayerVersionPolicyCommand,
  GetPolicyCommand,
  GetProvisionedConcurrencyConfigCommand,
  GetRuntimeManagementConfigCommand,
  InvokeCommand,
  InvokeAsyncCommand,
  InvokeWithResponseStreamCommand,
  ListAliasesCommand,
  ListCodeSigningConfigsCommand,
  ListEventSourceMappingsCommand,
  ListFunctionEventInvokeConfigsCommand,
  ListFunctionsCommand,
  ListFunctionsByCodeSigningConfigCommand,
  ListFunctionUrlConfigsCommand,
  ListLayersCommand,
  ListLayerVersionsCommand,
  ListProvisionedConcurrencyConfigsCommand,
  ListTagsCommand,
  ListVersionsByFunctionCommand,
  PublishLayerVersionCommand,
  PublishVersionCommand,
  PutFunctionCodeSigningConfigCommand,
  PutFunctionConcurrencyCommand,
  PutFunctionEventInvokeConfigCommand,
  PutFunctionRecursionConfigCommand,
  PutProvisionedConcurrencyConfigCommand,
  PutRuntimeManagementConfigCommand,
  RemoveLayerVersionPermissionCommand,
  RemovePermissionCommand,
  TagResourceCommand,
  UntagResourceCommand,
  UpdateAliasCommand,
  UpdateCodeSigningConfigCommand,
  UpdateEventSourceMappingCommand,
  UpdateFunctionCodeCommand,
  UpdateFunctionConfigurationCommand,
  UpdateFunctionEventInvokeConfigCommand,
  UpdateFunctionUrlConfigCommand
};
var Lambda = class extends LambdaClient {
  static {
    __name(this, "Lambda");
  }
};
(0, import_smithy_client.createAggregatedClient)(commands, Lambda);

// src/pagination/ListAliasesPaginator.ts

var paginateListAliases = (0, import_core.createPaginator)(LambdaClient, ListAliasesCommand, "Marker", "NextMarker", "MaxItems");

// src/pagination/ListCodeSigningConfigsPaginator.ts

var paginateListCodeSigningConfigs = (0, import_core.createPaginator)(LambdaClient, ListCodeSigningConfigsCommand, "Marker", "NextMarker", "MaxItems");

// src/pagination/ListEventSourceMappingsPaginator.ts

var paginateListEventSourceMappings = (0, import_core.createPaginator)(LambdaClient, ListEventSourceMappingsCommand, "Marker", "NextMarker", "MaxItems");

// src/pagination/ListFunctionEventInvokeConfigsPaginator.ts

var paginateListFunctionEventInvokeConfigs = (0, import_core.createPaginator)(LambdaClient, ListFunctionEventInvokeConfigsCommand, "Marker", "NextMarker", "MaxItems");

// src/pagination/ListFunctionUrlConfigsPaginator.ts

var paginateListFunctionUrlConfigs = (0, import_core.createPaginator)(LambdaClient, ListFunctionUrlConfigsCommand, "Marker", "NextMarker", "MaxItems");

// src/pagination/ListFunctionsByCodeSigningConfigPaginator.ts

var paginateListFunctionsByCodeSigningConfig = (0, import_core.createPaginator)(LambdaClient, ListFunctionsByCodeSigningConfigCommand, "Marker", "NextMarker", "MaxItems");

// src/pagination/ListFunctionsPaginator.ts

var paginateListFunctions = (0, import_core.createPaginator)(LambdaClient, ListFunctionsCommand, "Marker", "NextMarker", "MaxItems");

// src/pagination/ListLayerVersionsPaginator.ts

var paginateListLayerVersions = (0, import_core.createPaginator)(LambdaClient, ListLayerVersionsCommand, "Marker", "NextMarker", "MaxItems");

// src/pagination/ListLayersPaginator.ts

var paginateListLayers = (0, import_core.createPaginator)(LambdaClient, ListLayersCommand, "Marker", "NextMarker", "MaxItems");

// src/pagination/ListProvisionedConcurrencyConfigsPaginator.ts

var paginateListProvisionedConcurrencyConfigs = (0, import_core.createPaginator)(LambdaClient, ListProvisionedConcurrencyConfigsCommand, "Marker", "NextMarker", "MaxItems");

// src/pagination/ListVersionsByFunctionPaginator.ts

var paginateListVersionsByFunction = (0, import_core.createPaginator)(LambdaClient, ListVersionsByFunctionCommand, "Marker", "NextMarker", "MaxItems");

// src/waiters/waitForFunctionActive.ts
var import_util_waiter = require("@smithy/util-waiter");
var checkState = /* @__PURE__ */ __name(async (client, input) => {
  let reason;
  try {
    const result = await client.send(new GetFunctionConfigurationCommand(input));
    reason = result;
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.State;
      }, "returnComparator");
      if (returnComparator() === "Active") {
        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
      }
    } catch (e) {
    }
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.State;
      }, "returnComparator");
      if (returnComparator() === "Failed") {
        return { state: import_util_waiter.WaiterState.FAILURE, reason };
      }
    } catch (e) {
    }
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.State;
      }, "returnComparator");
      if (returnComparator() === "Pending") {
        return { state: import_util_waiter.WaiterState.RETRY, reason };
      }
    } catch (e) {
    }
  } catch (exception) {
    reason = exception;
  }
  return { state: import_util_waiter.WaiterState.RETRY, reason };
}, "checkState");
var waitForFunctionActive = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 5, maxDelay: 300 };
  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
}, "waitForFunctionActive");
var waitUntilFunctionActive = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 5, maxDelay: 300 };
  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
  return (0, import_util_waiter.checkExceptions)(result);
}, "waitUntilFunctionActive");

// src/waiters/waitForFunctionActiveV2.ts

var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
  let reason;
  try {
    const result = await client.send(new GetFunctionCommand(input));
    reason = result;
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.Configuration.State;
      }, "returnComparator");
      if (returnComparator() === "Active") {
        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
      }
    } catch (e) {
    }
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.Configuration.State;
      }, "returnComparator");
      if (returnComparator() === "Failed") {
        return { state: import_util_waiter.WaiterState.FAILURE, reason };
      }
    } catch (e) {
    }
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.Configuration.State;
      }, "returnComparator");
      if (returnComparator() === "Pending") {
        return { state: import_util_waiter.WaiterState.RETRY, reason };
      }
    } catch (e) {
    }
  } catch (exception) {
    reason = exception;
  }
  return { state: import_util_waiter.WaiterState.RETRY, reason };
}, "checkState");
var waitForFunctionActiveV2 = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 1, maxDelay: 300 };
  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
}, "waitForFunctionActiveV2");
var waitUntilFunctionActiveV2 = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 1, maxDelay: 300 };
  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
  return (0, import_util_waiter.checkExceptions)(result);
}, "waitUntilFunctionActiveV2");

// src/waiters/waitForFunctionExists.ts

var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
  let reason;
  try {
    const result = await client.send(new GetFunctionCommand(input));
    reason = result;
    return { state: import_util_waiter.WaiterState.SUCCESS, reason };
  } catch (exception) {
    reason = exception;
    if (exception.name && exception.name == "ResourceNotFoundException") {
      return { state: import_util_waiter.WaiterState.RETRY, reason };
    }
  }
  return { state: import_util_waiter.WaiterState.RETRY, reason };
}, "checkState");
var waitForFunctionExists = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 1, maxDelay: 20 };
  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
}, "waitForFunctionExists");
var waitUntilFunctionExists = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 1, maxDelay: 20 };
  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
  return (0, import_util_waiter.checkExceptions)(result);
}, "waitUntilFunctionExists");

// src/waiters/waitForFunctionUpdated.ts

var checkState4 = /* @__PURE__ */ __name(async (client, input) => {
  let reason;
  try {
    const result = await client.send(new GetFunctionConfigurationCommand(input));
    reason = result;
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.LastUpdateStatus;
      }, "returnComparator");
      if (returnComparator() === "Successful") {
        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
      }
    } catch (e) {
    }
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.LastUpdateStatus;
      }, "returnComparator");
      if (returnComparator() === "Failed") {
        return { state: import_util_waiter.WaiterState.FAILURE, reason };
      }
    } catch (e) {
    }
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.LastUpdateStatus;
      }, "returnComparator");
      if (returnComparator() === "InProgress") {
        return { state: import_util_waiter.WaiterState.RETRY, reason };
      }
    } catch (e) {
    }
  } catch (exception) {
    reason = exception;
  }
  return { state: import_util_waiter.WaiterState.RETRY, reason };
}, "checkState");
var waitForFunctionUpdated = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 5, maxDelay: 300 };
  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
}, "waitForFunctionUpdated");
var waitUntilFunctionUpdated = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 5, maxDelay: 300 };
  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
  return (0, import_util_waiter.checkExceptions)(result);
}, "waitUntilFunctionUpdated");

// src/waiters/waitForFunctionUpdatedV2.ts

var checkState5 = /* @__PURE__ */ __name(async (client, input) => {
  let reason;
  try {
    const result = await client.send(new GetFunctionCommand(input));
    reason = result;
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.Configuration.LastUpdateStatus;
      }, "returnComparator");
      if (returnComparator() === "Successful") {
        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
      }
    } catch (e) {
    }
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.Configuration.LastUpdateStatus;
      }, "returnComparator");
      if (returnComparator() === "Failed") {
        return { state: import_util_waiter.WaiterState.FAILURE, reason };
      }
    } catch (e) {
    }
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.Configuration.LastUpdateStatus;
      }, "returnComparator");
      if (returnComparator() === "InProgress") {
        return { state: import_util_waiter.WaiterState.RETRY, reason };
      }
    } catch (e) {
    }
  } catch (exception) {
    reason = exception;
  }
  return { state: import_util_waiter.WaiterState.RETRY, reason };
}, "checkState");
var waitForFunctionUpdatedV2 = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 1, maxDelay: 300 };
  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState5);
}, "waitForFunctionUpdatedV2");
var waitUntilFunctionUpdatedV2 = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 1, maxDelay: 300 };
  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState5);
  return (0, import_util_waiter.checkExceptions)(result);
}, "waitUntilFunctionUpdatedV2");

// src/waiters/waitForPublishedVersionActive.ts

var checkState6 = /* @__PURE__ */ __name(async (client, input) => {
  let reason;
  try {
    const result = await client.send(new GetFunctionConfigurationCommand(input));
    reason = result;
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.State;
      }, "returnComparator");
      if (returnComparator() === "Active") {
        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
      }
    } catch (e) {
    }
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.State;
      }, "returnComparator");
      if (returnComparator() === "Failed") {
        return { state: import_util_waiter.WaiterState.FAILURE, reason };
      }
    } catch (e) {
    }
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        return result.State;
      }, "returnComparator");
      if (returnComparator() === "Pending") {
        return { state: import_util_waiter.WaiterState.RETRY, reason };
      }
    } catch (e) {
    }
  } catch (exception) {
    reason = exception;
  }
  return { state: import_util_waiter.WaiterState.RETRY, reason };
}, "checkState");
var waitForPublishedVersionActive = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 5, maxDelay: 1560 };
  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState6);
}, "waitForPublishedVersionActive");
var waitUntilPublishedVersionActive = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 5, maxDelay: 1560 };
  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState6);
  return (0, import_util_waiter.checkExceptions)(result);
}, "waitUntilPublishedVersionActive");
// Annotate the CommonJS export names for ESM import in node:

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