@aws-sdk/client-apprunner 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3367 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppRunnerServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./AppRunnerClient"), exports);
-tslib_1.__exportStar(require("./AppRunner"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var AppRunnerServiceException_1 = require("./models/AppRunnerServiceException");
-Object.defineProperty(exports, "AppRunnerServiceException", { enumerable: true, get: function () { return AppRunnerServiceException_1.AppRunnerServiceException; } });
+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 src_exports = {};
+__export(src_exports, {
+  AppRunner: () => AppRunner,
+  AppRunnerClient: () => AppRunnerClient,
+  AppRunnerServiceException: () => AppRunnerServiceException,
+  AssociateCustomDomainCommand: () => AssociateCustomDomainCommand,
+  AutoScalingConfigurationStatus: () => AutoScalingConfigurationStatus,
+  CertificateValidationRecordStatus: () => CertificateValidationRecordStatus,
+  CodeConfigurationFilterSensitiveLog: () => CodeConfigurationFilterSensitiveLog,
+  CodeConfigurationValuesFilterSensitiveLog: () => CodeConfigurationValuesFilterSensitiveLog,
+  CodeRepositoryFilterSensitiveLog: () => CodeRepositoryFilterSensitiveLog,
+  ConfigurationSource: () => ConfigurationSource,
+  ConnectionStatus: () => ConnectionStatus,
+  CreateAutoScalingConfigurationCommand: () => CreateAutoScalingConfigurationCommand,
+  CreateConnectionCommand: () => CreateConnectionCommand,
+  CreateObservabilityConfigurationCommand: () => CreateObservabilityConfigurationCommand,
+  CreateServiceCommand: () => CreateServiceCommand,
+  CreateServiceRequestFilterSensitiveLog: () => CreateServiceRequestFilterSensitiveLog,
+  CreateServiceResponseFilterSensitiveLog: () => CreateServiceResponseFilterSensitiveLog,
+  CreateVpcConnectorCommand: () => CreateVpcConnectorCommand,
+  CreateVpcIngressConnectionCommand: () => CreateVpcIngressConnectionCommand,
+  CustomDomainAssociationStatus: () => CustomDomainAssociationStatus,
+  DeleteAutoScalingConfigurationCommand: () => DeleteAutoScalingConfigurationCommand,
+  DeleteConnectionCommand: () => DeleteConnectionCommand,
+  DeleteObservabilityConfigurationCommand: () => DeleteObservabilityConfigurationCommand,
+  DeleteServiceCommand: () => DeleteServiceCommand,
+  DeleteServiceResponseFilterSensitiveLog: () => DeleteServiceResponseFilterSensitiveLog,
+  DeleteVpcConnectorCommand: () => DeleteVpcConnectorCommand,
+  DeleteVpcIngressConnectionCommand: () => DeleteVpcIngressConnectionCommand,
+  DescribeAutoScalingConfigurationCommand: () => DescribeAutoScalingConfigurationCommand,
+  DescribeCustomDomainsCommand: () => DescribeCustomDomainsCommand,
+  DescribeObservabilityConfigurationCommand: () => DescribeObservabilityConfigurationCommand,
+  DescribeServiceCommand: () => DescribeServiceCommand,
+  DescribeServiceResponseFilterSensitiveLog: () => DescribeServiceResponseFilterSensitiveLog,
+  DescribeVpcConnectorCommand: () => DescribeVpcConnectorCommand,
+  DescribeVpcIngressConnectionCommand: () => DescribeVpcIngressConnectionCommand,
+  DisassociateCustomDomainCommand: () => DisassociateCustomDomainCommand,
+  EgressType: () => EgressType,
+  HealthCheckProtocol: () => HealthCheckProtocol,
+  ImageConfigurationFilterSensitiveLog: () => ImageConfigurationFilterSensitiveLog,
+  ImageRepositoryFilterSensitiveLog: () => ImageRepositoryFilterSensitiveLog,
+  ImageRepositoryType: () => ImageRepositoryType,
+  InternalServiceErrorException: () => InternalServiceErrorException,
+  InvalidRequestException: () => InvalidRequestException,
+  InvalidStateException: () => InvalidStateException,
+  IpAddressType: () => IpAddressType,
+  ListAutoScalingConfigurationsCommand: () => ListAutoScalingConfigurationsCommand,
+  ListConnectionsCommand: () => ListConnectionsCommand,
+  ListObservabilityConfigurationsCommand: () => ListObservabilityConfigurationsCommand,
+  ListOperationsCommand: () => ListOperationsCommand,
+  ListServicesCommand: () => ListServicesCommand,
+  ListServicesForAutoScalingConfigurationCommand: () => ListServicesForAutoScalingConfigurationCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ListVpcConnectorsCommand: () => ListVpcConnectorsCommand,
+  ListVpcIngressConnectionsCommand: () => ListVpcIngressConnectionsCommand,
+  ObservabilityConfigurationStatus: () => ObservabilityConfigurationStatus,
+  OperationStatus: () => OperationStatus,
+  OperationType: () => OperationType,
+  PauseServiceCommand: () => PauseServiceCommand,
+  PauseServiceResponseFilterSensitiveLog: () => PauseServiceResponseFilterSensitiveLog,
+  ProviderType: () => ProviderType,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ResumeServiceCommand: () => ResumeServiceCommand,
+  ResumeServiceResponseFilterSensitiveLog: () => ResumeServiceResponseFilterSensitiveLog,
+  Runtime: () => Runtime,
+  ServiceFilterSensitiveLog: () => ServiceFilterSensitiveLog,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  ServiceStatus: () => ServiceStatus,
+  SourceCodeVersionType: () => SourceCodeVersionType,
+  SourceConfigurationFilterSensitiveLog: () => SourceConfigurationFilterSensitiveLog,
+  StartDeploymentCommand: () => StartDeploymentCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  TracingVendor: () => TracingVendor,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateDefaultAutoScalingConfigurationCommand: () => UpdateDefaultAutoScalingConfigurationCommand,
+  UpdateServiceCommand: () => UpdateServiceCommand,
+  UpdateServiceRequestFilterSensitiveLog: () => UpdateServiceRequestFilterSensitiveLog,
+  UpdateServiceResponseFilterSensitiveLog: () => UpdateServiceResponseFilterSensitiveLog,
+  UpdateVpcIngressConnectionCommand: () => UpdateVpcIngressConnectionCommand,
+  VpcConnectorStatus: () => VpcConnectorStatus,
+  VpcIngressConnectionStatus: () => VpcIngressConnectionStatus,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeCustomDomains: () => paginateDescribeCustomDomains,
+  paginateListAutoScalingConfigurations: () => paginateListAutoScalingConfigurations,
+  paginateListConnections: () => paginateListConnections,
+  paginateListObservabilityConfigurations: () => paginateListObservabilityConfigurations,
+  paginateListOperations: () => paginateListOperations,
+  paginateListServices: () => paginateListServices,
+  paginateListServicesForAutoScalingConfiguration: () => paginateListServicesForAutoScalingConfiguration,
+  paginateListVpcConnectors: () => paginateListVpcConnectors,
+  paginateListVpcIngressConnections: () => paginateListVpcIngressConnections
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/AppRunnerClient.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_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/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");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "apprunner"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/AppRunnerClient.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");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/AppRunnerClient.ts
+var _AppRunnerClient = class _AppRunnerClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    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_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(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();
+  }
+};
+__name(_AppRunnerClient, "AppRunnerClient");
+var AppRunnerClient = _AppRunnerClient;
+
+// src/AppRunner.ts
+
+
+// src/commands/AssociateCustomDomainCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_0.ts
+
+
+
+// src/models/AppRunnerServiceException.ts
+
+var _AppRunnerServiceException = class _AppRunnerServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _AppRunnerServiceException.prototype);
+  }
+};
+__name(_AppRunnerServiceException, "AppRunnerServiceException");
+var AppRunnerServiceException = _AppRunnerServiceException;
+
+// src/models/models_0.ts
+
+var CertificateValidationRecordStatus = {
+  FAILED: "FAILED",
+  PENDING_VALIDATION: "PENDING_VALIDATION",
+  SUCCESS: "SUCCESS"
+};
+var CustomDomainAssociationStatus = {
+  ACTIVE: "ACTIVE",
+  BINDING_CERTIFICATE: "BINDING_CERTIFICATE",
+  CREATE_FAILED: "CREATE_FAILED",
+  CREATING: "CREATING",
+  DELETE_FAILED: "DELETE_FAILED",
+  DELETING: "DELETING",
+  PENDING_CERTIFICATE_DNS_VALIDATION: "PENDING_CERTIFICATE_DNS_VALIDATION"
+};
+var _InternalServiceErrorException = class _InternalServiceErrorException extends AppRunnerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServiceErrorException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServiceErrorException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServiceErrorException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalServiceErrorException, "InternalServiceErrorException");
+var InternalServiceErrorException = _InternalServiceErrorException;
+var _InvalidRequestException = class _InvalidRequestException extends AppRunnerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidRequestException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidRequestException, "InvalidRequestException");
+var InvalidRequestException = _InvalidRequestException;
+var _InvalidStateException = class _InvalidStateException extends AppRunnerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidStateException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidStateException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidStateException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidStateException, "InvalidStateException");
+var InvalidStateException = _InvalidStateException;
+var AutoScalingConfigurationStatus = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE"
+};
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends AppRunnerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var ProviderType = {
+  BITBUCKET: "BITBUCKET",
+  GITHUB: "GITHUB"
+};
+var ConnectionStatus = {
+  AVAILABLE: "AVAILABLE",
+  DELETED: "DELETED",
+  ERROR: "ERROR",
+  PENDING_HANDSHAKE: "PENDING_HANDSHAKE"
+};
+var TracingVendor = {
+  AWSXRAY: "AWSXRAY"
+};
+var ObservabilityConfigurationStatus = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE"
+};
+var HealthCheckProtocol = {
+  HTTP: "HTTP",
+  TCP: "TCP"
+};
+var EgressType = {
+  DEFAULT: "DEFAULT",
+  VPC: "VPC"
+};
+var IpAddressType = {
+  DUAL_STACK: "DUAL_STACK",
+  IPV4: "IPV4"
+};
+var Runtime = {
+  CORRETTO_11: "CORRETTO_11",
+  CORRETTO_8: "CORRETTO_8",
+  DOTNET_6: "DOTNET_6",
+  GO_1: "GO_1",
+  NODEJS_12: "NODEJS_12",
+  NODEJS_14: "NODEJS_14",
+  NODEJS_16: "NODEJS_16",
+  NODEJS_18: "NODEJS_18",
+  PHP_81: "PHP_81",
+  PYTHON_3: "PYTHON_3",
+  PYTHON_311: "PYTHON_311",
+  RUBY_31: "RUBY_31"
+};
+var ConfigurationSource = {
+  API: "API",
+  REPOSITORY: "REPOSITORY"
+};
+var SourceCodeVersionType = {
+  BRANCH: "BRANCH"
+};
+var ImageRepositoryType = {
+  ECR: "ECR",
+  ECR_PUBLIC: "ECR_PUBLIC"
+};
+var ServiceStatus = {
+  CREATE_FAILED: "CREATE_FAILED",
+  DELETED: "DELETED",
+  DELETE_FAILED: "DELETE_FAILED",
+  OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS",
+  PAUSED: "PAUSED",
+  RUNNING: "RUNNING"
+};
+var VpcConnectorStatus = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE"
+};
+var VpcIngressConnectionStatus = {
+  AVAILABLE: "AVAILABLE",
+  DELETED: "DELETED",
+  FAILED_CREATION: "FAILED_CREATION",
+  FAILED_DELETION: "FAILED_DELETION",
+  FAILED_UPDATE: "FAILED_UPDATE",
+  PENDING_CREATION: "PENDING_CREATION",
+  PENDING_DELETION: "PENDING_DELETION",
+  PENDING_UPDATE: "PENDING_UPDATE"
+};
+var _ResourceNotFoundException = class _ResourceNotFoundException extends AppRunnerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var OperationStatus = {
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS",
+  PENDING: "PENDING",
+  ROLLBACK_FAILED: "ROLLBACK_FAILED",
+  ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS",
+  ROLLBACK_SUCCEEDED: "ROLLBACK_SUCCEEDED",
+  SUCCEEDED: "SUCCEEDED"
+};
+var OperationType = {
+  CREATE_SERVICE: "CREATE_SERVICE",
+  DELETE_SERVICE: "DELETE_SERVICE",
+  PAUSE_SERVICE: "PAUSE_SERVICE",
+  RESUME_SERVICE: "RESUME_SERVICE",
+  START_DEPLOYMENT: "START_DEPLOYMENT",
+  UPDATE_SERVICE: "UPDATE_SERVICE"
+};
+var CodeConfigurationValuesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.BuildCommand && { BuildCommand: import_smithy_client.SENSITIVE_STRING },
+  ...obj.StartCommand && { StartCommand: import_smithy_client.SENSITIVE_STRING },
+  ...obj.RuntimeEnvironmentVariables && { RuntimeEnvironmentVariables: import_smithy_client.SENSITIVE_STRING },
+  ...obj.RuntimeEnvironmentSecrets && { RuntimeEnvironmentSecrets: import_smithy_client.SENSITIVE_STRING }
+}), "CodeConfigurationValuesFilterSensitiveLog");
+var CodeConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.CodeConfigurationValues && {
+    CodeConfigurationValues: CodeConfigurationValuesFilterSensitiveLog(obj.CodeConfigurationValues)
+  }
+}), "CodeConfigurationFilterSensitiveLog");
+var CodeRepositoryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.CodeConfiguration && { CodeConfiguration: CodeConfigurationFilterSensitiveLog(obj.CodeConfiguration) }
+}), "CodeRepositoryFilterSensitiveLog");
+var ImageConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RuntimeEnvironmentVariables && { RuntimeEnvironmentVariables: import_smithy_client.SENSITIVE_STRING },
+  ...obj.StartCommand && { StartCommand: import_smithy_client.SENSITIVE_STRING },
+  ...obj.RuntimeEnvironmentSecrets && { RuntimeEnvironmentSecrets: import_smithy_client.SENSITIVE_STRING }
+}), "ImageConfigurationFilterSensitiveLog");
+var ImageRepositoryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ImageConfiguration && { ImageConfiguration: ImageConfigurationFilterSensitiveLog(obj.ImageConfiguration) }
+}), "ImageRepositoryFilterSensitiveLog");
+var SourceConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.CodeRepository && { CodeRepository: CodeRepositoryFilterSensitiveLog(obj.CodeRepository) },
+  ...obj.ImageRepository && { ImageRepository: ImageRepositoryFilterSensitiveLog(obj.ImageRepository) }
+}), "SourceConfigurationFilterSensitiveLog");
+var CreateServiceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.SourceConfiguration && {
+    SourceConfiguration: SourceConfigurationFilterSensitiveLog(obj.SourceConfiguration)
+  }
+}), "CreateServiceRequestFilterSensitiveLog");
+var ServiceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.SourceConfiguration && {
+    SourceConfiguration: SourceConfigurationFilterSensitiveLog(obj.SourceConfiguration)
+  }
+}), "ServiceFilterSensitiveLog");
+var CreateServiceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Service && { Service: ServiceFilterSensitiveLog(obj.Service) }
+}), "CreateServiceResponseFilterSensitiveLog");
+var DeleteServiceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Service && { Service: ServiceFilterSensitiveLog(obj.Service) }
+}), "DeleteServiceResponseFilterSensitiveLog");
+var DescribeServiceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Service && { Service: ServiceFilterSensitiveLog(obj.Service) }
+}), "DescribeServiceResponseFilterSensitiveLog");
+var PauseServiceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Service && { Service: ServiceFilterSensitiveLog(obj.Service) }
+}), "PauseServiceResponseFilterSensitiveLog");
+var ResumeServiceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Service && { Service: ServiceFilterSensitiveLog(obj.Service) }
+}), "ResumeServiceResponseFilterSensitiveLog");
+var UpdateServiceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.SourceConfiguration && {
+    SourceConfiguration: SourceConfigurationFilterSensitiveLog(obj.SourceConfiguration)
+  }
+}), "UpdateServiceRequestFilterSensitiveLog");
+var UpdateServiceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Service && { Service: ServiceFilterSensitiveLog(obj.Service) }
+}), "UpdateServiceResponseFilterSensitiveLog");
+
+// src/protocols/Aws_json1_0.ts
+var se_AssociateCustomDomainCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateCustomDomain");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateCustomDomainCommand");
+var se_CreateAutoScalingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateAutoScalingConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateAutoScalingConfigurationCommand");
+var se_CreateConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateConnectionCommand");
+var se_CreateObservabilityConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateObservabilityConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateObservabilityConfigurationCommand");
+var se_CreateServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateService");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateServiceCommand");
+var se_CreateVpcConnectorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateVpcConnector");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateVpcConnectorCommand");
+var se_CreateVpcIngressConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateVpcIngressConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateVpcIngressConnectionCommand");
+var se_DeleteAutoScalingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteAutoScalingConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteAutoScalingConfigurationCommand");
+var se_DeleteConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteConnectionCommand");
+var se_DeleteObservabilityConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteObservabilityConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteObservabilityConfigurationCommand");
+var se_DeleteServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteService");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteServiceCommand");
+var se_DeleteVpcConnectorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteVpcConnector");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteVpcConnectorCommand");
+var se_DeleteVpcIngressConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteVpcIngressConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteVpcIngressConnectionCommand");
+var se_DescribeAutoScalingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeAutoScalingConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeAutoScalingConfigurationCommand");
+var se_DescribeCustomDomainsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeCustomDomains");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeCustomDomainsCommand");
+var se_DescribeObservabilityConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeObservabilityConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeObservabilityConfigurationCommand");
+var se_DescribeServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeService");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeServiceCommand");
+var se_DescribeVpcConnectorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeVpcConnector");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeVpcConnectorCommand");
+var se_DescribeVpcIngressConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeVpcIngressConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeVpcIngressConnectionCommand");
+var se_DisassociateCustomDomainCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DisassociateCustomDomain");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisassociateCustomDomainCommand");
+var se_ListAutoScalingConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListAutoScalingConfigurations");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListAutoScalingConfigurationsCommand");
+var se_ListConnectionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListConnections");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListConnectionsCommand");
+var se_ListObservabilityConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListObservabilityConfigurations");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListObservabilityConfigurationsCommand");
+var se_ListOperationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListOperations");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListOperationsCommand");
+var se_ListServicesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListServices");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListServicesCommand");
+var se_ListServicesForAutoScalingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListServicesForAutoScalingConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListServicesForAutoScalingConfigurationCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTagsForResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTagsForResourceCommand");
+var se_ListVpcConnectorsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListVpcConnectors");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListVpcConnectorsCommand");
+var se_ListVpcIngressConnectionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListVpcIngressConnections");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListVpcIngressConnectionsCommand");
+var se_PauseServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PauseService");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PauseServiceCommand");
+var se_ResumeServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ResumeService");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ResumeServiceCommand");
+var se_StartDeploymentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartDeployment");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartDeploymentCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagResourceCommand");
+var se_UpdateDefaultAutoScalingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateDefaultAutoScalingConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateDefaultAutoScalingConfigurationCommand");
+var se_UpdateServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateService");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateServiceCommand");
+var se_UpdateVpcIngressConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateVpcIngressConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateVpcIngressConnectionCommand");
+var de_AssociateCustomDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateCustomDomainCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AssociateCustomDomainCommand");
+var de_AssociateCustomDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateCustomDomainCommandError");
+var de_CreateAutoScalingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateAutoScalingConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateAutoScalingConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateAutoScalingConfigurationCommand");
+var de_CreateAutoScalingConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.apprunner#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateAutoScalingConfigurationCommandError");
+var de_CreateConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateConnectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateConnectionCommand");
+var de_CreateConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.apprunner#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateConnectionCommandError");
+var de_CreateObservabilityConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateObservabilityConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateObservabilityConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateObservabilityConfigurationCommand");
+var de_CreateObservabilityConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.apprunner#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateObservabilityConfigurationCommandError");
+var de_CreateServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateServiceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateServiceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateServiceCommand");
+var de_CreateServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.apprunner#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateServiceCommandError");
+var de_CreateVpcConnectorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateVpcConnectorCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateVpcConnectorResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateVpcConnectorCommand");
+var de_CreateVpcConnectorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.apprunner#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateVpcConnectorCommandError");
+var de_CreateVpcIngressConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateVpcIngressConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateVpcIngressConnectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateVpcIngressConnectionCommand");
+var de_CreateVpcIngressConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.apprunner#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateVpcIngressConnectionCommandError");
+var de_DeleteAutoScalingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteAutoScalingConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteAutoScalingConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteAutoScalingConfigurationCommand");
+var de_DeleteAutoScalingConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteAutoScalingConfigurationCommandError");
+var de_DeleteConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteConnectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteConnectionCommand");
+var de_DeleteConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteConnectionCommandError");
+var de_DeleteObservabilityConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteObservabilityConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteObservabilityConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteObservabilityConfigurationCommand");
+var de_DeleteObservabilityConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteObservabilityConfigurationCommandError");
+var de_DeleteServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteServiceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteServiceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteServiceCommand");
+var de_DeleteServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteServiceCommandError");
+var de_DeleteVpcConnectorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteVpcConnectorCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteVpcConnectorResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteVpcConnectorCommand");
+var de_DeleteVpcConnectorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVpcConnectorCommandError");
+var de_DeleteVpcIngressConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteVpcIngressConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteVpcIngressConnectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteVpcIngressConnectionCommand");
+var de_DeleteVpcIngressConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVpcIngressConnectionCommandError");
+var de_DescribeAutoScalingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeAutoScalingConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeAutoScalingConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeAutoScalingConfigurationCommand");
+var de_DescribeAutoScalingConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeAutoScalingConfigurationCommandError");
+var de_DescribeCustomDomainsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeCustomDomainsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeCustomDomainsCommand");
+var de_DescribeCustomDomainsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCustomDomainsCommandError");
+var de_DescribeObservabilityConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeObservabilityConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeObservabilityConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeObservabilityConfigurationCommand");
+var de_DescribeObservabilityConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeObservabilityConfigurationCommandError");
+var de_DescribeServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeServiceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeServiceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeServiceCommand");
+var de_DescribeServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeServiceCommandError");
+var de_DescribeVpcConnectorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeVpcConnectorCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeVpcConnectorResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeVpcConnectorCommand");
+var de_DescribeVpcConnectorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeVpcConnectorCommandError");
+var de_DescribeVpcIngressConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeVpcIngressConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeVpcIngressConnectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeVpcIngressConnectionCommand");
+var de_DescribeVpcIngressConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeVpcIngressConnectionCommandError");
+var de_DisassociateCustomDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisassociateCustomDomainCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DisassociateCustomDomainCommand");
+var de_DisassociateCustomDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisassociateCustomDomainCommandError");
+var de_ListAutoScalingConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListAutoScalingConfigurationsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListAutoScalingConfigurationsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListAutoScalingConfigurationsCommand");
+var de_ListAutoScalingConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAutoScalingConfigurationsCommandError");
+var de_ListConnectionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListConnectionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListConnectionsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListConnectionsCommand");
+var de_ListConnectionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListConnectionsCommandError");
+var de_ListObservabilityConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListObservabilityConfigurationsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListObservabilityConfigurationsCommand");
+var de_ListObservabilityConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListObservabilityConfigurationsCommandError");
+var de_ListOperationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListOperationsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListOperationsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListOperationsCommand");
+var de_ListOperationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListOperationsCommandError");
+var de_ListServicesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListServicesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListServicesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListServicesCommand");
+var de_ListServicesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListServicesCommandError");
+var de_ListServicesForAutoScalingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListServicesForAutoScalingConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListServicesForAutoScalingConfigurationCommand");
+var de_ListServicesForAutoScalingConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListServicesForAutoScalingConfigurationCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ListVpcConnectorsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListVpcConnectorsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListVpcConnectorsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListVpcConnectorsCommand");
+var de_ListVpcConnectorsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListVpcConnectorsCommandError");
+var de_ListVpcIngressConnectionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListVpcIngressConnectionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListVpcIngressConnectionsCommand");
+var de_ListVpcIngressConnectionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListVpcIngressConnectionsCommandError");
+var de_PauseServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PauseServiceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_PauseServiceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PauseServiceCommand");
+var de_PauseServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PauseServiceCommandError");
+var de_ResumeServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ResumeServiceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ResumeServiceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ResumeServiceCommand");
+var de_ResumeServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ResumeServiceCommandError");
+var de_StartDeploymentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartDeploymentCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartDeploymentCommand");
+var de_StartDeploymentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartDeploymentCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateDefaultAutoScalingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateDefaultAutoScalingConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateDefaultAutoScalingConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateDefaultAutoScalingConfigurationCommand");
+var de_UpdateDefaultAutoScalingConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateDefaultAutoScalingConfigurationCommandError");
+var de_UpdateServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateServiceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateServiceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateServiceCommand");
+var de_UpdateServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateServiceCommandError");
+var de_UpdateVpcIngressConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateVpcIngressConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateVpcIngressConnectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateVpcIngressConnectionCommand");
+var de_UpdateVpcIngressConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceErrorException":
+    case "com.amazonaws.apprunner#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.apprunner#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.apprunner#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.apprunner#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateVpcIngressConnectionCommandError");
+var de_InternalServiceErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InternalServiceErrorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalServiceErrorExceptionRes");
+var de_InvalidRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidRequestExceptionRes");
+var de_InvalidStateExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidStateException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidStateExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_AutoScalingConfiguration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutoScalingConfigurationArn: import_smithy_client.expectString,
+    AutoScalingConfigurationName: import_smithy_client.expectString,
+    AutoScalingConfigurationRevision: import_smithy_client.expectInt32,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DeletedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    HasAssociatedService: import_smithy_client.expectBoolean,
+    IsDefault: import_smithy_client.expectBoolean,
+    Latest: import_smithy_client.expectBoolean,
+    MaxConcurrency: import_smithy_client.expectInt32,
+    MaxSize: import_smithy_client.expectInt32,
+    MinSize: import_smithy_client.expectInt32,
+    Status: import_smithy_client.expectString
+  });
+}, "de_AutoScalingConfiguration");
+var de_AutoScalingConfigurationSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutoScalingConfigurationArn: import_smithy_client.expectString,
+    AutoScalingConfigurationName: import_smithy_client.expectString,
+    AutoScalingConfigurationRevision: import_smithy_client.expectInt32,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    HasAssociatedService: import_smithy_client.expectBoolean,
+    IsDefault: import_smithy_client.expectBoolean,
+    Status: import_smithy_client.expectString
+  });
+}, "de_AutoScalingConfigurationSummary");
+var de_AutoScalingConfigurationSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AutoScalingConfigurationSummary(entry, context);
+  });
+  return retVal;
+}, "de_AutoScalingConfigurationSummaryList");
+var de_Connection = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ConnectionArn: import_smithy_client.expectString,
+    ConnectionName: import_smithy_client.expectString,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ProviderType: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+}, "de_Connection");
+var de_ConnectionSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ConnectionArn: import_smithy_client.expectString,
+    ConnectionName: import_smithy_client.expectString,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ProviderType: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+}, "de_ConnectionSummary");
+var de_ConnectionSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ConnectionSummary(entry, context);
+  });
+  return retVal;
+}, "de_ConnectionSummaryList");
+var de_CreateAutoScalingConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutoScalingConfiguration: (_) => de_AutoScalingConfiguration(_, context)
+  });
+}, "de_CreateAutoScalingConfigurationResponse");
+var de_CreateConnectionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Connection: (_) => de_Connection(_, context)
+  });
+}, "de_CreateConnectionResponse");
+var de_CreateObservabilityConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ObservabilityConfiguration: (_) => de_ObservabilityConfiguration(_, context)
+  });
+}, "de_CreateObservabilityConfigurationResponse");
+var de_CreateServiceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    OperationId: import_smithy_client.expectString,
+    Service: (_) => de_Service(_, context)
+  });
+}, "de_CreateServiceResponse");
+var de_CreateVpcConnectorResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    VpcConnector: (_) => de_VpcConnector(_, context)
+  });
+}, "de_CreateVpcConnectorResponse");
+var de_CreateVpcIngressConnectionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    VpcIngressConnection: (_) => de_VpcIngressConnection(_, context)
+  });
+}, "de_CreateVpcIngressConnectionResponse");
+var de_DeleteAutoScalingConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutoScalingConfiguration: (_) => de_AutoScalingConfiguration(_, context)
+  });
+}, "de_DeleteAutoScalingConfigurationResponse");
+var de_DeleteConnectionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Connection: (_) => de_Connection(_, context)
+  });
+}, "de_DeleteConnectionResponse");
+var de_DeleteObservabilityConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ObservabilityConfiguration: (_) => de_ObservabilityConfiguration(_, context)
+  });
+}, "de_DeleteObservabilityConfigurationResponse");
+var de_DeleteServiceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    OperationId: import_smithy_client.expectString,
+    Service: (_) => de_Service(_, context)
+  });
+}, "de_DeleteServiceResponse");
+var de_DeleteVpcConnectorResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    VpcConnector: (_) => de_VpcConnector(_, context)
+  });
+}, "de_DeleteVpcConnectorResponse");
+var de_DeleteVpcIngressConnectionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    VpcIngressConnection: (_) => de_VpcIngressConnection(_, context)
+  });
+}, "de_DeleteVpcIngressConnectionResponse");
+var de_DescribeAutoScalingConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutoScalingConfiguration: (_) => de_AutoScalingConfiguration(_, context)
+  });
+}, "de_DescribeAutoScalingConfigurationResponse");
+var de_DescribeObservabilityConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ObservabilityConfiguration: (_) => de_ObservabilityConfiguration(_, context)
+  });
+}, "de_DescribeObservabilityConfigurationResponse");
+var de_DescribeServiceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Service: (_) => de_Service(_, context)
+  });
+}, "de_DescribeServiceResponse");
+var de_DescribeVpcConnectorResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    VpcConnector: (_) => de_VpcConnector(_, context)
+  });
+}, "de_DescribeVpcConnectorResponse");
+var de_DescribeVpcIngressConnectionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    VpcIngressConnection: (_) => de_VpcIngressConnection(_, context)
+  });
+}, "de_DescribeVpcIngressConnectionResponse");
+var de_ListAutoScalingConfigurationsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutoScalingConfigurationSummaryList: (_) => de_AutoScalingConfigurationSummaryList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListAutoScalingConfigurationsResponse");
+var de_ListConnectionsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ConnectionSummaryList: (_) => de_ConnectionSummaryList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListConnectionsResponse");
+var de_ListOperationsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    OperationSummaryList: (_) => de_OperationSummaryList(_, context)
+  });
+}, "de_ListOperationsResponse");
+var de_ListServicesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    ServiceSummaryList: (_) => de_ServiceSummaryList(_, context)
+  });
+}, "de_ListServicesResponse");
+var de_ListVpcConnectorsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    VpcConnectors: (_) => de_VpcConnectors(_, context)
+  });
+}, "de_ListVpcConnectorsResponse");
+var de_ObservabilityConfiguration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DeletedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Latest: import_smithy_client.expectBoolean,
+    ObservabilityConfigurationArn: import_smithy_client.expectString,
+    ObservabilityConfigurationName: import_smithy_client.expectString,
+    ObservabilityConfigurationRevision: import_smithy_client.expectInt32,
+    Status: import_smithy_client.expectString,
+    TraceConfiguration: import_smithy_client._json
+  });
+}, "de_ObservabilityConfiguration");
+var de_OperationSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    EndedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Id: import_smithy_client.expectString,
+    StartedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString,
+    TargetArn: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString,
+    UpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_OperationSummary");
+var de_OperationSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_OperationSummary(entry, context);
+  });
+  return retVal;
+}, "de_OperationSummaryList");
+var de_PauseServiceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    OperationId: import_smithy_client.expectString,
+    Service: (_) => de_Service(_, context)
+  });
+}, "de_PauseServiceResponse");
+var de_ResumeServiceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    OperationId: import_smithy_client.expectString,
+    Service: (_) => de_Service(_, context)
+  });
+}, "de_ResumeServiceResponse");
+var de_Service = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutoScalingConfigurationSummary: (_) => de_AutoScalingConfigurationSummary(_, context),
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DeletedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    EncryptionConfiguration: import_smithy_client._json,
+    HealthCheckConfiguration: import_smithy_client._json,
+    InstanceConfiguration: import_smithy_client._json,
+    NetworkConfiguration: import_smithy_client._json,
+    ObservabilityConfiguration: import_smithy_client._json,
+    ServiceArn: import_smithy_client.expectString,
+    ServiceId: import_smithy_client.expectString,
+    ServiceName: import_smithy_client.expectString,
+    ServiceUrl: import_smithy_client.expectString,
+    SourceConfiguration: import_smithy_client._json,
+    Status: import_smithy_client.expectString,
+    UpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_Service");
+var de_ServiceSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ServiceArn: import_smithy_client.expectString,
+    ServiceId: import_smithy_client.expectString,
+    ServiceName: import_smithy_client.expectString,
+    ServiceUrl: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    UpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_ServiceSummary");
+var de_ServiceSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ServiceSummary(entry, context);
+  });
+  return retVal;
+}, "de_ServiceSummaryList");
+var de_UpdateDefaultAutoScalingConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutoScalingConfiguration: (_) => de_AutoScalingConfiguration(_, context)
+  });
+}, "de_UpdateDefaultAutoScalingConfigurationResponse");
+var de_UpdateServiceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    OperationId: import_smithy_client.expectString,
+    Service: (_) => de_Service(_, context)
+  });
+}, "de_UpdateServiceResponse");
+var de_UpdateVpcIngressConnectionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    VpcIngressConnection: (_) => de_VpcIngressConnection(_, context)
+  });
+}, "de_UpdateVpcIngressConnectionResponse");
+var de_VpcConnector = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DeletedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    SecurityGroups: import_smithy_client._json,
+    Status: import_smithy_client.expectString,
+    Subnets: import_smithy_client._json,
+    VpcConnectorArn: import_smithy_client.expectString,
+    VpcConnectorName: import_smithy_client.expectString,
+    VpcConnectorRevision: import_smithy_client.expectInt32
+  });
+}, "de_VpcConnector");
+var de_VpcConnectors = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_VpcConnector(entry, context);
+  });
+  return retVal;
+}, "de_VpcConnectors");
+var de_VpcIngressConnection = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AccountId: import_smithy_client.expectString,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DeletedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DomainName: import_smithy_client.expectString,
+    IngressVpcConfiguration: import_smithy_client._json,
+    ServiceArn: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    VpcIngressConnectionArn: import_smithy_client.expectString,
+    VpcIngressConnectionName: import_smithy_client.expectString
+  });
+}, "de_VpcIngressConnection");
+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 collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(AppRunnerServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.0",
+    "x-amz-target": `AppRunner.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/AssociateCustomDomainCommand.ts
+var _AssociateCustomDomainCommand = class _AssociateCustomDomainCommand 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("AppRunner", "AssociateCustomDomain", {}).n("AppRunnerClient", "AssociateCustomDomainCommand").f(void 0, void 0).ser(se_AssociateCustomDomainCommand).de(de_AssociateCustomDomainCommand).build() {
+};
+__name(_AssociateCustomDomainCommand, "AssociateCustomDomainCommand");
+var AssociateCustomDomainCommand = _AssociateCustomDomainCommand;
+
+// src/commands/CreateAutoScalingConfigurationCommand.ts
+
+
+
+
+var _CreateAutoScalingConfigurationCommand = class _CreateAutoScalingConfigurationCommand 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("AppRunner", "CreateAutoScalingConfiguration", {}).n("AppRunnerClient", "CreateAutoScalingConfigurationCommand").f(void 0, void 0).ser(se_CreateAutoScalingConfigurationCommand).de(de_CreateAutoScalingConfigurationCommand).build() {
+};
+__name(_CreateAutoScalingConfigurationCommand, "CreateAutoScalingConfigurationCommand");
+var CreateAutoScalingConfigurationCommand = _CreateAutoScalingConfigurationCommand;
+
+// src/commands/CreateConnectionCommand.ts
+
+
+
+
+var _CreateConnectionCommand = class _CreateConnectionCommand 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("AppRunner", "CreateConnection", {}).n("AppRunnerClient", "CreateConnectionCommand").f(void 0, void 0).ser(se_CreateConnectionCommand).de(de_CreateConnectionCommand).build() {
+};
+__name(_CreateConnectionCommand, "CreateConnectionCommand");
+var CreateConnectionCommand = _CreateConnectionCommand;
+
+// src/commands/CreateObservabilityConfigurationCommand.ts
+
+
+
+
+var _CreateObservabilityConfigurationCommand = class _CreateObservabilityConfigurationCommand 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("AppRunner", "CreateObservabilityConfiguration", {}).n("AppRunnerClient", "CreateObservabilityConfigurationCommand").f(void 0, void 0).ser(se_CreateObservabilityConfigurationCommand).de(de_CreateObservabilityConfigurationCommand).build() {
+};
+__name(_CreateObservabilityConfigurationCommand, "CreateObservabilityConfigurationCommand");
+var CreateObservabilityConfigurationCommand = _CreateObservabilityConfigurationCommand;
+
+// src/commands/CreateServiceCommand.ts
+
+
+
+
+var _CreateServiceCommand = class _CreateServiceCommand 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("AppRunner", "CreateService", {}).n("AppRunnerClient", "CreateServiceCommand").f(CreateServiceRequestFilterSensitiveLog, CreateServiceResponseFilterSensitiveLog).ser(se_CreateServiceCommand).de(de_CreateServiceCommand).build() {
+};
+__name(_CreateServiceCommand, "CreateServiceCommand");
+var CreateServiceCommand = _CreateServiceCommand;
+
+// src/commands/CreateVpcConnectorCommand.ts
+
+
+
+
+var _CreateVpcConnectorCommand = class _CreateVpcConnectorCommand 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("AppRunner", "CreateVpcConnector", {}).n("AppRunnerClient", "CreateVpcConnectorCommand").f(void 0, void 0).ser(se_CreateVpcConnectorCommand).de(de_CreateVpcConnectorCommand).build() {
+};
+__name(_CreateVpcConnectorCommand, "CreateVpcConnectorCommand");
+var CreateVpcConnectorCommand = _CreateVpcConnectorCommand;
+
+// src/commands/CreateVpcIngressConnectionCommand.ts
+
+
+
+
+var _CreateVpcIngressConnectionCommand = class _CreateVpcIngressConnectionCommand 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("AppRunner", "CreateVpcIngressConnection", {}).n("AppRunnerClient", "CreateVpcIngressConnectionCommand").f(void 0, void 0).ser(se_CreateVpcIngressConnectionCommand).de(de_CreateVpcIngressConnectionCommand).build() {
+};
+__name(_CreateVpcIngressConnectionCommand, "CreateVpcIngressConnectionCommand");
+var CreateVpcIngressConnectionCommand = _CreateVpcIngressConnectionCommand;
+
+// src/commands/DeleteAutoScalingConfigurationCommand.ts
+
+
+
+
+var _DeleteAutoScalingConfigurationCommand = class _DeleteAutoScalingConfigurationCommand 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("AppRunner", "DeleteAutoScalingConfiguration", {}).n("AppRunnerClient", "DeleteAutoScalingConfigurationCommand").f(void 0, void 0).ser(se_DeleteAutoScalingConfigurationCommand).de(de_DeleteAutoScalingConfigurationCommand).build() {
+};
+__name(_DeleteAutoScalingConfigurationCommand, "DeleteAutoScalingConfigurationCommand");
+var DeleteAutoScalingConfigurationCommand = _DeleteAutoScalingConfigurationCommand;
+
+// src/commands/DeleteConnectionCommand.ts
+
+
+
+
+var _DeleteConnectionCommand = class _DeleteConnectionCommand 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("AppRunner", "DeleteConnection", {}).n("AppRunnerClient", "DeleteConnectionCommand").f(void 0, void 0).ser(se_DeleteConnectionCommand).de(de_DeleteConnectionCommand).build() {
+};
+__name(_DeleteConnectionCommand, "DeleteConnectionCommand");
+var DeleteConnectionCommand = _DeleteConnectionCommand;
+
+// src/commands/DeleteObservabilityConfigurationCommand.ts
+
+
+
+
+var _DeleteObservabilityConfigurationCommand = class _DeleteObservabilityConfigurationCommand 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("AppRunner", "DeleteObservabilityConfiguration", {}).n("AppRunnerClient", "DeleteObservabilityConfigurationCommand").f(void 0, void 0).ser(se_DeleteObservabilityConfigurationCommand).de(de_DeleteObservabilityConfigurationCommand).build() {
+};
+__name(_DeleteObservabilityConfigurationCommand, "DeleteObservabilityConfigurationCommand");
+var DeleteObservabilityConfigurationCommand = _DeleteObservabilityConfigurationCommand;
+
+// src/commands/DeleteServiceCommand.ts
+
+
+
+
+var _DeleteServiceCommand = class _DeleteServiceCommand 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("AppRunner", "DeleteService", {}).n("AppRunnerClient", "DeleteServiceCommand").f(void 0, DeleteServiceResponseFilterSensitiveLog).ser(se_DeleteServiceCommand).de(de_DeleteServiceCommand).build() {
+};
+__name(_DeleteServiceCommand, "DeleteServiceCommand");
+var DeleteServiceCommand = _DeleteServiceCommand;
+
+// src/commands/DeleteVpcConnectorCommand.ts
+
+
+
+
+var _DeleteVpcConnectorCommand = class _DeleteVpcConnectorCommand 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("AppRunner", "DeleteVpcConnector", {}).n("AppRunnerClient", "DeleteVpcConnectorCommand").f(void 0, void 0).ser(se_DeleteVpcConnectorCommand).de(de_DeleteVpcConnectorCommand).build() {
+};
+__name(_DeleteVpcConnectorCommand, "DeleteVpcConnectorCommand");
+var DeleteVpcConnectorCommand = _DeleteVpcConnectorCommand;
+
+// src/commands/DeleteVpcIngressConnectionCommand.ts
+
+
+
+
+var _DeleteVpcIngressConnectionCommand = class _DeleteVpcIngressConnectionCommand 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("AppRunner", "DeleteVpcIngressConnection", {}).n("AppRunnerClient", "DeleteVpcIngressConnectionCommand").f(void 0, void 0).ser(se_DeleteVpcIngressConnectionCommand).de(de_DeleteVpcIngressConnectionCommand).build() {
+};
+__name(_DeleteVpcIngressConnectionCommand, "DeleteVpcIngressConnectionCommand");
+var DeleteVpcIngressConnectionCommand = _DeleteVpcIngressConnectionCommand;
+
+// src/commands/DescribeAutoScalingConfigurationCommand.ts
+
+
+
+
+var _DescribeAutoScalingConfigurationCommand = class _DescribeAutoScalingConfigurationCommand 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("AppRunner", "DescribeAutoScalingConfiguration", {}).n("AppRunnerClient", "DescribeAutoScalingConfigurationCommand").f(void 0, void 0).ser(se_DescribeAutoScalingConfigurationCommand).de(de_DescribeAutoScalingConfigurationCommand).build() {
+};
+__name(_DescribeAutoScalingConfigurationCommand, "DescribeAutoScalingConfigurationCommand");
+var DescribeAutoScalingConfigurationCommand = _DescribeAutoScalingConfigurationCommand;
+
+// src/commands/DescribeCustomDomainsCommand.ts
+
+
+
+
+var _DescribeCustomDomainsCommand = class _DescribeCustomDomainsCommand 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("AppRunner", "DescribeCustomDomains", {}).n("AppRunnerClient", "DescribeCustomDomainsCommand").f(void 0, void 0).ser(se_DescribeCustomDomainsCommand).de(de_DescribeCustomDomainsCommand).build() {
+};
+__name(_DescribeCustomDomainsCommand, "DescribeCustomDomainsCommand");
+var DescribeCustomDomainsCommand = _DescribeCustomDomainsCommand;
+
+// src/commands/DescribeObservabilityConfigurationCommand.ts
+
+
+
+
+var _DescribeObservabilityConfigurationCommand = class _DescribeObservabilityConfigurationCommand 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("AppRunner", "DescribeObservabilityConfiguration", {}).n("AppRunnerClient", "DescribeObservabilityConfigurationCommand").f(void 0, void 0).ser(se_DescribeObservabilityConfigurationCommand).de(de_DescribeObservabilityConfigurationCommand).build() {
+};
+__name(_DescribeObservabilityConfigurationCommand, "DescribeObservabilityConfigurationCommand");
+var DescribeObservabilityConfigurationCommand = _DescribeObservabilityConfigurationCommand;
+
+// src/commands/DescribeServiceCommand.ts
+
+
+
+
+var _DescribeServiceCommand = class _DescribeServiceCommand 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("AppRunner", "DescribeService", {}).n("AppRunnerClient", "DescribeServiceCommand").f(void 0, DescribeServiceResponseFilterSensitiveLog).ser(se_DescribeServiceCommand).de(de_DescribeServiceCommand).build() {
+};
+__name(_DescribeServiceCommand, "DescribeServiceCommand");
+var DescribeServiceCommand = _DescribeServiceCommand;
+
+// src/commands/DescribeVpcConnectorCommand.ts
+
+
+
+
+var _DescribeVpcConnectorCommand = class _DescribeVpcConnectorCommand 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("AppRunner", "DescribeVpcConnector", {}).n("AppRunnerClient", "DescribeVpcConnectorCommand").f(void 0, void 0).ser(se_DescribeVpcConnectorCommand).de(de_DescribeVpcConnectorCommand).build() {
+};
+__name(_DescribeVpcConnectorCommand, "DescribeVpcConnectorCommand");
+var DescribeVpcConnectorCommand = _DescribeVpcConnectorCommand;
+
+// src/commands/DescribeVpcIngressConnectionCommand.ts
+
+
+
+
+var _DescribeVpcIngressConnectionCommand = class _DescribeVpcIngressConnectionCommand 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("AppRunner", "DescribeVpcIngressConnection", {}).n("AppRunnerClient", "DescribeVpcIngressConnectionCommand").f(void 0, void 0).ser(se_DescribeVpcIngressConnectionCommand).de(de_DescribeVpcIngressConnectionCommand).build() {
+};
+__name(_DescribeVpcIngressConnectionCommand, "DescribeVpcIngressConnectionCommand");
+var DescribeVpcIngressConnectionCommand = _DescribeVpcIngressConnectionCommand;
+
+// src/commands/DisassociateCustomDomainCommand.ts
+
+
+
+
+var _DisassociateCustomDomainCommand = class _DisassociateCustomDomainCommand 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("AppRunner", "DisassociateCustomDomain", {}).n("AppRunnerClient", "DisassociateCustomDomainCommand").f(void 0, void 0).ser(se_DisassociateCustomDomainCommand).de(de_DisassociateCustomDomainCommand).build() {
+};
+__name(_DisassociateCustomDomainCommand, "DisassociateCustomDomainCommand");
+var DisassociateCustomDomainCommand = _DisassociateCustomDomainCommand;
+
+// src/commands/ListAutoScalingConfigurationsCommand.ts
+
+
+
+
+var _ListAutoScalingConfigurationsCommand = class _ListAutoScalingConfigurationsCommand 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("AppRunner", "ListAutoScalingConfigurations", {}).n("AppRunnerClient", "ListAutoScalingConfigurationsCommand").f(void 0, void 0).ser(se_ListAutoScalingConfigurationsCommand).de(de_ListAutoScalingConfigurationsCommand).build() {
+};
+__name(_ListAutoScalingConfigurationsCommand, "ListAutoScalingConfigurationsCommand");
+var ListAutoScalingConfigurationsCommand = _ListAutoScalingConfigurationsCommand;
+
+// src/commands/ListConnectionsCommand.ts
+
+
+
+
+var _ListConnectionsCommand = class _ListConnectionsCommand 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("AppRunner", "ListConnections", {}).n("AppRunnerClient", "ListConnectionsCommand").f(void 0, void 0).ser(se_ListConnectionsCommand).de(de_ListConnectionsCommand).build() {
+};
+__name(_ListConnectionsCommand, "ListConnectionsCommand");
+var ListConnectionsCommand = _ListConnectionsCommand;
+
+// src/commands/ListObservabilityConfigurationsCommand.ts
+
+
+
+
+var _ListObservabilityConfigurationsCommand = class _ListObservabilityConfigurationsCommand 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("AppRunner", "ListObservabilityConfigurations", {}).n("AppRunnerClient", "ListObservabilityConfigurationsCommand").f(void 0, void 0).ser(se_ListObservabilityConfigurationsCommand).de(de_ListObservabilityConfigurationsCommand).build() {
+};
+__name(_ListObservabilityConfigurationsCommand, "ListObservabilityConfigurationsCommand");
+var ListObservabilityConfigurationsCommand = _ListObservabilityConfigurationsCommand;
+
+// src/commands/ListOperationsCommand.ts
+
+
+
+
+var _ListOperationsCommand = class _ListOperationsCommand 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("AppRunner", "ListOperations", {}).n("AppRunnerClient", "ListOperationsCommand").f(void 0, void 0).ser(se_ListOperationsCommand).de(de_ListOperationsCommand).build() {
+};
+__name(_ListOperationsCommand, "ListOperationsCommand");
+var ListOperationsCommand = _ListOperationsCommand;
+
+// src/commands/ListServicesCommand.ts
+
+
+
+
+var _ListServicesCommand = class _ListServicesCommand 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("AppRunner", "ListServices", {}).n("AppRunnerClient", "ListServicesCommand").f(void 0, void 0).ser(se_ListServicesCommand).de(de_ListServicesCommand).build() {
+};
+__name(_ListServicesCommand, "ListServicesCommand");
+var ListServicesCommand = _ListServicesCommand;
+
+// src/commands/ListServicesForAutoScalingConfigurationCommand.ts
+
+
+
+
+var _ListServicesForAutoScalingConfigurationCommand = class _ListServicesForAutoScalingConfigurationCommand 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("AppRunner", "ListServicesForAutoScalingConfiguration", {}).n("AppRunnerClient", "ListServicesForAutoScalingConfigurationCommand").f(void 0, void 0).ser(se_ListServicesForAutoScalingConfigurationCommand).de(de_ListServicesForAutoScalingConfigurationCommand).build() {
+};
+__name(_ListServicesForAutoScalingConfigurationCommand, "ListServicesForAutoScalingConfigurationCommand");
+var ListServicesForAutoScalingConfigurationCommand = _ListServicesForAutoScalingConfigurationCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand 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("AppRunner", "ListTagsForResource", {}).n("AppRunnerClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ListVpcConnectorsCommand.ts
+
+
+
+
+var _ListVpcConnectorsCommand = class _ListVpcConnectorsCommand 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("AppRunner", "ListVpcConnectors", {}).n("AppRunnerClient", "ListVpcConnectorsCommand").f(void 0, void 0).ser(se_ListVpcConnectorsCommand).de(de_ListVpcConnectorsCommand).build() {
+};
+__name(_ListVpcConnectorsCommand, "ListVpcConnectorsCommand");
+var ListVpcConnectorsCommand = _ListVpcConnectorsCommand;
+
+// src/commands/ListVpcIngressConnectionsCommand.ts
+
+
+
+
+var _ListVpcIngressConnectionsCommand = class _ListVpcIngressConnectionsCommand 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("AppRunner", "ListVpcIngressConnections", {}).n("AppRunnerClient", "ListVpcIngressConnectionsCommand").f(void 0, void 0).ser(se_ListVpcIngressConnectionsCommand).de(de_ListVpcIngressConnectionsCommand).build() {
+};
+__name(_ListVpcIngressConnectionsCommand, "ListVpcIngressConnectionsCommand");
+var ListVpcIngressConnectionsCommand = _ListVpcIngressConnectionsCommand;
+
+// src/commands/PauseServiceCommand.ts
+
+
+
+
+var _PauseServiceCommand = class _PauseServiceCommand 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("AppRunner", "PauseService", {}).n("AppRunnerClient", "PauseServiceCommand").f(void 0, PauseServiceResponseFilterSensitiveLog).ser(se_PauseServiceCommand).de(de_PauseServiceCommand).build() {
+};
+__name(_PauseServiceCommand, "PauseServiceCommand");
+var PauseServiceCommand = _PauseServiceCommand;
+
+// src/commands/ResumeServiceCommand.ts
+
+
+
+
+var _ResumeServiceCommand = class _ResumeServiceCommand 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("AppRunner", "ResumeService", {}).n("AppRunnerClient", "ResumeServiceCommand").f(void 0, ResumeServiceResponseFilterSensitiveLog).ser(se_ResumeServiceCommand).de(de_ResumeServiceCommand).build() {
+};
+__name(_ResumeServiceCommand, "ResumeServiceCommand");
+var ResumeServiceCommand = _ResumeServiceCommand;
+
+// src/commands/StartDeploymentCommand.ts
+
+
+
+
+var _StartDeploymentCommand = class _StartDeploymentCommand 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("AppRunner", "StartDeployment", {}).n("AppRunnerClient", "StartDeploymentCommand").f(void 0, void 0).ser(se_StartDeploymentCommand).de(de_StartDeploymentCommand).build() {
+};
+__name(_StartDeploymentCommand, "StartDeploymentCommand");
+var StartDeploymentCommand = _StartDeploymentCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand 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("AppRunner", "TagResource", {}).n("AppRunnerClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand 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("AppRunner", "UntagResource", {}).n("AppRunnerClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateDefaultAutoScalingConfigurationCommand.ts
+
+
+
+
+var _UpdateDefaultAutoScalingConfigurationCommand = class _UpdateDefaultAutoScalingConfigurationCommand 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("AppRunner", "UpdateDefaultAutoScalingConfiguration", {}).n("AppRunnerClient", "UpdateDefaultAutoScalingConfigurationCommand").f(void 0, void 0).ser(se_UpdateDefaultAutoScalingConfigurationCommand).de(de_UpdateDefaultAutoScalingConfigurationCommand).build() {
+};
+__name(_UpdateDefaultAutoScalingConfigurationCommand, "UpdateDefaultAutoScalingConfigurationCommand");
+var UpdateDefaultAutoScalingConfigurationCommand = _UpdateDefaultAutoScalingConfigurationCommand;
+
+// src/commands/UpdateServiceCommand.ts
+
+
+
+
+var _UpdateServiceCommand = class _UpdateServiceCommand 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("AppRunner", "UpdateService", {}).n("AppRunnerClient", "UpdateServiceCommand").f(UpdateServiceRequestFilterSensitiveLog, UpdateServiceResponseFilterSensitiveLog).ser(se_UpdateServiceCommand).de(de_UpdateServiceCommand).build() {
+};
+__name(_UpdateServiceCommand, "UpdateServiceCommand");
+var UpdateServiceCommand = _UpdateServiceCommand;
+
+// src/commands/UpdateVpcIngressConnectionCommand.ts
+
+
+
+
+var _UpdateVpcIngressConnectionCommand = class _UpdateVpcIngressConnectionCommand 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("AppRunner", "UpdateVpcIngressConnection", {}).n("AppRunnerClient", "UpdateVpcIngressConnectionCommand").f(void 0, void 0).ser(se_UpdateVpcIngressConnectionCommand).de(de_UpdateVpcIngressConnectionCommand).build() {
+};
+__name(_UpdateVpcIngressConnectionCommand, "UpdateVpcIngressConnectionCommand");
+var UpdateVpcIngressConnectionCommand = _UpdateVpcIngressConnectionCommand;
+
+// src/AppRunner.ts
+var commands = {
+  AssociateCustomDomainCommand,
+  CreateAutoScalingConfigurationCommand,
+  CreateConnectionCommand,
+  CreateObservabilityConfigurationCommand,
+  CreateServiceCommand,
+  CreateVpcConnectorCommand,
+  CreateVpcIngressConnectionCommand,
+  DeleteAutoScalingConfigurationCommand,
+  DeleteConnectionCommand,
+  DeleteObservabilityConfigurationCommand,
+  DeleteServiceCommand,
+  DeleteVpcConnectorCommand,
+  DeleteVpcIngressConnectionCommand,
+  DescribeAutoScalingConfigurationCommand,
+  DescribeCustomDomainsCommand,
+  DescribeObservabilityConfigurationCommand,
+  DescribeServiceCommand,
+  DescribeVpcConnectorCommand,
+  DescribeVpcIngressConnectionCommand,
+  DisassociateCustomDomainCommand,
+  ListAutoScalingConfigurationsCommand,
+  ListConnectionsCommand,
+  ListObservabilityConfigurationsCommand,
+  ListOperationsCommand,
+  ListServicesCommand,
+  ListServicesForAutoScalingConfigurationCommand,
+  ListTagsForResourceCommand,
+  ListVpcConnectorsCommand,
+  ListVpcIngressConnectionsCommand,
+  PauseServiceCommand,
+  ResumeServiceCommand,
+  StartDeploymentCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateDefaultAutoScalingConfigurationCommand,
+  UpdateServiceCommand,
+  UpdateVpcIngressConnectionCommand
+};
+var _AppRunner = class _AppRunner extends AppRunnerClient {
+};
+__name(_AppRunner, "AppRunner");
+var AppRunner = _AppRunner;
+(0, import_smithy_client.createAggregatedClient)(commands, AppRunner);
+
+// src/pagination/DescribeCustomDomainsPaginator.ts
+var import_core = require("@smithy/core");
+var paginateDescribeCustomDomains = (0, import_core.createPaginator)(AppRunnerClient, DescribeCustomDomainsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListAutoScalingConfigurationsPaginator.ts
+
+var paginateListAutoScalingConfigurations = (0, import_core.createPaginator)(AppRunnerClient, ListAutoScalingConfigurationsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListConnectionsPaginator.ts
+
+var paginateListConnections = (0, import_core.createPaginator)(AppRunnerClient, ListConnectionsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListObservabilityConfigurationsPaginator.ts
+
+var paginateListObservabilityConfigurations = (0, import_core.createPaginator)(AppRunnerClient, ListObservabilityConfigurationsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListOperationsPaginator.ts
+
+var paginateListOperations = (0, import_core.createPaginator)(AppRunnerClient, ListOperationsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListServicesForAutoScalingConfigurationPaginator.ts
+
+var paginateListServicesForAutoScalingConfiguration = (0, import_core.createPaginator)(AppRunnerClient, ListServicesForAutoScalingConfigurationCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListServicesPaginator.ts
+
+var paginateListServices = (0, import_core.createPaginator)(AppRunnerClient, ListServicesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListVpcConnectorsPaginator.ts
+
+var paginateListVpcConnectors = (0, import_core.createPaginator)(AppRunnerClient, ListVpcConnectorsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListVpcIngressConnectionsPaginator.ts
+
+var paginateListVpcIngressConnections = (0, import_core.createPaginator)(AppRunnerClient, ListVpcIngressConnectionsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppRunner,
+  AppRunnerClient,
+  AppRunnerServiceException,
+  AssociateCustomDomainCommand,
+  AutoScalingConfigurationStatus,
+  CertificateValidationRecordStatus,
+  CodeConfigurationFilterSensitiveLog,
+  CodeConfigurationValuesFilterSensitiveLog,
+  CodeRepositoryFilterSensitiveLog,
+  ConfigurationSource,
+  ConnectionStatus,
+  CreateAutoScalingConfigurationCommand,
+  CreateConnectionCommand,
+  CreateObservabilityConfigurationCommand,
+  CreateServiceCommand,
+  CreateServiceRequestFilterSensitiveLog,
+  CreateServiceResponseFilterSensitiveLog,
+  CreateVpcConnectorCommand,
+  CreateVpcIngressConnectionCommand,
+  CustomDomainAssociationStatus,
+  DeleteAutoScalingConfigurationCommand,
+  DeleteConnectionCommand,
+  DeleteObservabilityConfigurationCommand,
+  DeleteServiceCommand,
+  DeleteServiceResponseFilterSensitiveLog,
+  DeleteVpcConnectorCommand,
+  DeleteVpcIngressConnectionCommand,
+  DescribeAutoScalingConfigurationCommand,
+  DescribeCustomDomainsCommand,
+  DescribeObservabilityConfigurationCommand,
+  DescribeServiceCommand,
+  DescribeServiceResponseFilterSensitiveLog,
+  DescribeVpcConnectorCommand,
+  DescribeVpcIngressConnectionCommand,
+  DisassociateCustomDomainCommand,
+  EgressType,
+  HealthCheckProtocol,
+  ImageConfigurationFilterSensitiveLog,
+  ImageRepositoryFilterSensitiveLog,
+  ImageRepositoryType,
+  InternalServiceErrorException,
+  InvalidRequestException,
+  InvalidStateException,
+  IpAddressType,
+  ListAutoScalingConfigurationsCommand,
+  ListConnectionsCommand,
+  ListObservabilityConfigurationsCommand,
+  ListOperationsCommand,
+  ListServicesCommand,
+  ListServicesForAutoScalingConfigurationCommand,
+  ListTagsForResourceCommand,
+  ListVpcConnectorsCommand,
+  ListVpcIngressConnectionsCommand,
+  ObservabilityConfigurationStatus,
+  OperationStatus,
+  OperationType,
+  PauseServiceCommand,
+  PauseServiceResponseFilterSensitiveLog,
+  ProviderType,
+  ResourceNotFoundException,
+  ResumeServiceCommand,
+  ResumeServiceResponseFilterSensitiveLog,
+  Runtime,
+  ServiceFilterSensitiveLog,
+  ServiceQuotaExceededException,
+  ServiceStatus,
+  SourceCodeVersionType,
+  SourceConfigurationFilterSensitiveLog,
+  StartDeploymentCommand,
+  TagResourceCommand,
+  TracingVendor,
+  UntagResourceCommand,
+  UpdateDefaultAutoScalingConfigurationCommand,
+  UpdateServiceCommand,
+  UpdateServiceRequestFilterSensitiveLog,
+  UpdateServiceResponseFilterSensitiveLog,
+  UpdateVpcIngressConnectionCommand,
+  VpcConnectorStatus,
+  VpcIngressConnectionStatus,
+  __Client,
+  paginateDescribeCustomDomains,
+  paginateListAutoScalingConfigurations,
+  paginateListConnections,
+  paginateListObservabilityConfigurations,
+  paginateListOperations,
+  paginateListServices,
+  paginateListServicesForAutoScalingConfiguration,
+  paginateListVpcConnectors,
+  paginateListVpcIngressConnections
+});