@rio-cloud/cdk-v2-constructs 6.10.2 → 6.10.3

package/node_modules/@aws-sdk/client-ecs/dist-cjs/index.js

@@ -0,0 +1,4387 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  AgentUpdateStatus: () => AgentUpdateStatus,
+  ApplicationProtocol: () => ApplicationProtocol,
+  AssignPublicIp: () => AssignPublicIp,
+  AttributeLimitExceededException: () => AttributeLimitExceededException,
+  BlockedException: () => BlockedException,
+  CPUArchitecture: () => CPUArchitecture,
+  CapacityProviderField: () => CapacityProviderField,
+  CapacityProviderStatus: () => CapacityProviderStatus,
+  CapacityProviderUpdateStatus: () => CapacityProviderUpdateStatus,
+  ClientException: () => ClientException,
+  ClusterContainsContainerInstancesException: () => ClusterContainsContainerInstancesException,
+  ClusterContainsServicesException: () => ClusterContainsServicesException,
+  ClusterContainsTasksException: () => ClusterContainsTasksException,
+  ClusterField: () => ClusterField,
+  ClusterNotFoundException: () => ClusterNotFoundException,
+  ClusterSettingName: () => ClusterSettingName,
+  Compatibility: () => Compatibility,
+  ConflictException: () => ConflictException,
+  Connectivity: () => Connectivity,
+  ContainerCondition: () => ContainerCondition,
+  ContainerInstanceField: () => ContainerInstanceField,
+  ContainerInstanceStatus: () => ContainerInstanceStatus,
+  CreateCapacityProviderCommand: () => CreateCapacityProviderCommand,
+  CreateClusterCommand: () => CreateClusterCommand,
+  CreateServiceCommand: () => CreateServiceCommand,
+  CreateTaskSetCommand: () => CreateTaskSetCommand,
+  DeleteAccountSettingCommand: () => DeleteAccountSettingCommand,
+  DeleteAttributesCommand: () => DeleteAttributesCommand,
+  DeleteCapacityProviderCommand: () => DeleteCapacityProviderCommand,
+  DeleteClusterCommand: () => DeleteClusterCommand,
+  DeleteServiceCommand: () => DeleteServiceCommand,
+  DeleteTaskDefinitionsCommand: () => DeleteTaskDefinitionsCommand,
+  DeleteTaskSetCommand: () => DeleteTaskSetCommand,
+  DeploymentControllerType: () => DeploymentControllerType,
+  DeploymentRolloutState: () => DeploymentRolloutState,
+  DeregisterContainerInstanceCommand: () => DeregisterContainerInstanceCommand,
+  DeregisterTaskDefinitionCommand: () => DeregisterTaskDefinitionCommand,
+  DescribeCapacityProvidersCommand: () => DescribeCapacityProvidersCommand,
+  DescribeClustersCommand: () => DescribeClustersCommand,
+  DescribeContainerInstancesCommand: () => DescribeContainerInstancesCommand,
+  DescribeServicesCommand: () => DescribeServicesCommand,
+  DescribeTaskDefinitionCommand: () => DescribeTaskDefinitionCommand,
+  DescribeTaskSetsCommand: () => DescribeTaskSetsCommand,
+  DescribeTasksCommand: () => DescribeTasksCommand,
+  DesiredStatus: () => DesiredStatus,
+  DeviceCgroupPermission: () => DeviceCgroupPermission,
+  DiscoverPollEndpointCommand: () => DiscoverPollEndpointCommand,
+  EBSResourceType: () => EBSResourceType,
+  ECS: () => ECS,
+  ECSClient: () => ECSClient,
+  ECSServiceException: () => ECSServiceException,
+  EFSAuthorizationConfigIAM: () => EFSAuthorizationConfigIAM,
+  EFSTransitEncryption: () => EFSTransitEncryption,
+  EnvironmentFileType: () => EnvironmentFileType,
+  ExecuteCommandCommand: () => ExecuteCommandCommand,
+  ExecuteCommandLogging: () => ExecuteCommandLogging,
+  ExecuteCommandResponseFilterSensitiveLog: () => ExecuteCommandResponseFilterSensitiveLog,
+  FirelensConfigurationType: () => FirelensConfigurationType,
+  GetTaskProtectionCommand: () => GetTaskProtectionCommand,
+  HealthStatus: () => HealthStatus,
+  InstanceHealthCheckState: () => InstanceHealthCheckState,
+  InstanceHealthCheckType: () => InstanceHealthCheckType,
+  InvalidParameterException: () => InvalidParameterException,
+  IpcMode: () => IpcMode,
+  LaunchType: () => LaunchType,
+  LimitExceededException: () => LimitExceededException,
+  ListAccountSettingsCommand: () => ListAccountSettingsCommand,
+  ListAttributesCommand: () => ListAttributesCommand,
+  ListClustersCommand: () => ListClustersCommand,
+  ListContainerInstancesCommand: () => ListContainerInstancesCommand,
+  ListServicesByNamespaceCommand: () => ListServicesByNamespaceCommand,
+  ListServicesCommand: () => ListServicesCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ListTaskDefinitionFamiliesCommand: () => ListTaskDefinitionFamiliesCommand,
+  ListTaskDefinitionsCommand: () => ListTaskDefinitionsCommand,
+  ListTasksCommand: () => ListTasksCommand,
+  LogDriver: () => LogDriver,
+  ManagedAgentName: () => ManagedAgentName,
+  ManagedDraining: () => ManagedDraining,
+  ManagedScalingStatus: () => ManagedScalingStatus,
+  ManagedTerminationProtection: () => ManagedTerminationProtection,
+  MissingVersionException: () => MissingVersionException,
+  NamespaceNotFoundException: () => NamespaceNotFoundException,
+  NetworkMode: () => NetworkMode,
+  NoUpdateAvailableException: () => NoUpdateAvailableException,
+  OSFamily: () => OSFamily,
+  PidMode: () => PidMode,
+  PlacementConstraintType: () => PlacementConstraintType,
+  PlacementStrategyType: () => PlacementStrategyType,
+  PlatformDeviceType: () => PlatformDeviceType,
+  PlatformTaskDefinitionIncompatibilityException: () => PlatformTaskDefinitionIncompatibilityException,
+  PlatformUnknownException: () => PlatformUnknownException,
+  PropagateTags: () => PropagateTags,
+  ProxyConfigurationType: () => ProxyConfigurationType,
+  PutAccountSettingCommand: () => PutAccountSettingCommand,
+  PutAccountSettingDefaultCommand: () => PutAccountSettingDefaultCommand,
+  PutAttributesCommand: () => PutAttributesCommand,
+  PutClusterCapacityProvidersCommand: () => PutClusterCapacityProvidersCommand,
+  RegisterContainerInstanceCommand: () => RegisterContainerInstanceCommand,
+  RegisterTaskDefinitionCommand: () => RegisterTaskDefinitionCommand,
+  ResourceInUseException: () => ResourceInUseException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ResourceType: () => ResourceType,
+  RunTaskCommand: () => RunTaskCommand,
+  ScaleUnit: () => ScaleUnit,
+  SchedulingStrategy: () => SchedulingStrategy,
+  Scope: () => Scope,
+  ServerException: () => ServerException,
+  ServiceField: () => ServiceField,
+  ServiceNotActiveException: () => ServiceNotActiveException,
+  ServiceNotFoundException: () => ServiceNotFoundException,
+  SessionFilterSensitiveLog: () => SessionFilterSensitiveLog,
+  SettingName: () => SettingName,
+  SettingType: () => SettingType,
+  SortOrder: () => SortOrder,
+  StabilityStatus: () => StabilityStatus,
+  StartTaskCommand: () => StartTaskCommand,
+  StopTaskCommand: () => StopTaskCommand,
+  SubmitAttachmentStateChangesCommand: () => SubmitAttachmentStateChangesCommand,
+  SubmitContainerStateChangeCommand: () => SubmitContainerStateChangeCommand,
+  SubmitTaskStateChangeCommand: () => SubmitTaskStateChangeCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  TargetNotConnectedException: () => TargetNotConnectedException,
+  TargetNotFoundException: () => TargetNotFoundException,
+  TargetType: () => TargetType,
+  TaskDefinitionFamilyStatus: () => TaskDefinitionFamilyStatus,
+  TaskDefinitionField: () => TaskDefinitionField,
+  TaskDefinitionPlacementConstraintType: () => TaskDefinitionPlacementConstraintType,
+  TaskDefinitionStatus: () => TaskDefinitionStatus,
+  TaskField: () => TaskField,
+  TaskFilesystemType: () => TaskFilesystemType,
+  TaskSetField: () => TaskSetField,
+  TaskSetNotFoundException: () => TaskSetNotFoundException,
+  TaskStopCode: () => TaskStopCode,
+  TransportProtocol: () => TransportProtocol,
+  UlimitName: () => UlimitName,
+  UnsupportedFeatureException: () => UnsupportedFeatureException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateCapacityProviderCommand: () => UpdateCapacityProviderCommand,
+  UpdateClusterCommand: () => UpdateClusterCommand,
+  UpdateClusterSettingsCommand: () => UpdateClusterSettingsCommand,
+  UpdateContainerAgentCommand: () => UpdateContainerAgentCommand,
+  UpdateContainerInstancesStateCommand: () => UpdateContainerInstancesStateCommand,
+  UpdateInProgressException: () => UpdateInProgressException,
+  UpdateServiceCommand: () => UpdateServiceCommand,
+  UpdateServicePrimaryTaskSetCommand: () => UpdateServicePrimaryTaskSetCommand,
+  UpdateTaskProtectionCommand: () => UpdateTaskProtectionCommand,
+  UpdateTaskSetCommand: () => UpdateTaskSetCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateListAccountSettings: () => paginateListAccountSettings,
+  paginateListAttributes: () => paginateListAttributes,
+  paginateListClusters: () => paginateListClusters,
+  paginateListContainerInstances: () => paginateListContainerInstances,
+  paginateListServices: () => paginateListServices,
+  paginateListServicesByNamespace: () => paginateListServicesByNamespace,
+  paginateListTaskDefinitionFamilies: () => paginateListTaskDefinitionFamilies,
+  paginateListTaskDefinitions: () => paginateListTaskDefinitions,
+  paginateListTasks: () => paginateListTasks,
+  waitForServicesInactive: () => waitForServicesInactive,
+  waitForServicesStable: () => waitForServicesStable,
+  waitForTasksRunning: () => waitForTasksRunning,
+  waitForTasksStopped: () => waitForTasksStopped,
+  waitUntilServicesInactive: () => waitUntilServicesInactive,
+  waitUntilServicesStable: () => waitUntilServicesStable,
+  waitUntilTasksRunning: () => waitUntilTasksRunning,
+  waitUntilTasksStopped: () => waitUntilTasksStopped
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ECSClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_core = require("@smithy/core");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "ecs"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/ECSClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+
+// src/auth/httpAuthExtensionConfiguration.ts
+var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+  let _credentials = runtimeConfig.credentials;
+  return {
+    setHttpAuthScheme(httpAuthScheme) {
+      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index === -1) {
+        _httpAuthSchemes.push(httpAuthScheme);
+      } else {
+        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+      }
+    },
+    httpAuthSchemes() {
+      return _httpAuthSchemes;
+    },
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+      _httpAuthSchemeProvider = httpAuthSchemeProvider;
+    },
+    httpAuthSchemeProvider() {
+      return _httpAuthSchemeProvider;
+    },
+    setCredentials(credentials) {
+      _credentials = credentials;
+    },
+    credentials() {
+      return _credentials;
+    }
+  };
+}, "getHttpAuthExtensionConfiguration");
+var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
+  return {
+    httpAuthSchemes: config.httpAuthSchemes(),
+    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+    credentials: config.credentials()
+  };
+}, "resolveHttpAuthRuntimeConfig");
+
+// src/runtimeExtensions.ts
+var 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)),
+    ...asPartial(getHttpAuthExtensionConfiguration(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),
+    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/ECSClient.ts
+var _ECSClient = class _ECSClient 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_middleware_user_agent.resolveUserAgentConfig)(_config_1);
+    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
+    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
+    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_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_user_agent.getUserAgentPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use(
+      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
+        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultECSHttpAuthSchemeParametersProvider,
+        identityProviderConfigProvider: async (config) => new import_core.DefaultIdentityProviderConfig({
+          "aws.auth#sigv4": config.credentials
+        })
+      })
+    );
+    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_ECSClient, "ECSClient");
+var ECSClient = _ECSClient;
+
+// src/ECS.ts
+
+
+// src/commands/CreateCapacityProviderCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+
+// src/protocols/Aws_json1_1.ts
+var import_core2 = require("@aws-sdk/core");
+
+
+var import_uuid = require("uuid");
+
+// src/models/ECSServiceException.ts
+
+var _ECSServiceException = class _ECSServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ECSServiceException.prototype);
+  }
+};
+__name(_ECSServiceException, "ECSServiceException");
+var ECSServiceException = _ECSServiceException;
+
+// src/models/models_0.ts
+
+var _AccessDeniedException = class _AccessDeniedException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var AgentUpdateStatus = {
+  FAILED: "FAILED",
+  PENDING: "PENDING",
+  STAGED: "STAGED",
+  STAGING: "STAGING",
+  UPDATED: "UPDATED",
+  UPDATING: "UPDATING"
+};
+var _ClientException = class _ClientException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ClientException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ClientException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ClientException.prototype);
+  }
+};
+__name(_ClientException, "ClientException");
+var ClientException = _ClientException;
+var ManagedDraining = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var ManagedScalingStatus = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var ManagedTerminationProtection = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var CapacityProviderStatus = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE"
+};
+var CapacityProviderUpdateStatus = {
+  DELETE_COMPLETE: "DELETE_COMPLETE",
+  DELETE_FAILED: "DELETE_FAILED",
+  DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
+  UPDATE_COMPLETE: "UPDATE_COMPLETE",
+  UPDATE_FAILED: "UPDATE_FAILED",
+  UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS"
+};
+var _InvalidParameterException = class _InvalidParameterException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidParameterException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidParameterException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidParameterException.prototype);
+  }
+};
+__name(_InvalidParameterException, "InvalidParameterException");
+var InvalidParameterException = _InvalidParameterException;
+var _LimitExceededException = class _LimitExceededException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var _ServerException = class _ServerException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ServerException.prototype);
+  }
+};
+__name(_ServerException, "ServerException");
+var ServerException = _ServerException;
+var _UpdateInProgressException = class _UpdateInProgressException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UpdateInProgressException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UpdateInProgressException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UpdateInProgressException.prototype);
+  }
+};
+__name(_UpdateInProgressException, "UpdateInProgressException");
+var UpdateInProgressException = _UpdateInProgressException;
+var ExecuteCommandLogging = {
+  DEFAULT: "DEFAULT",
+  NONE: "NONE",
+  OVERRIDE: "OVERRIDE"
+};
+var ClusterSettingName = {
+  CONTAINER_INSIGHTS: "containerInsights"
+};
+var _NamespaceNotFoundException = class _NamespaceNotFoundException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NamespaceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NamespaceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NamespaceNotFoundException.prototype);
+  }
+};
+__name(_NamespaceNotFoundException, "NamespaceNotFoundException");
+var NamespaceNotFoundException = _NamespaceNotFoundException;
+var _ClusterNotFoundException = class _ClusterNotFoundException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ClusterNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ClusterNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ClusterNotFoundException.prototype);
+  }
+};
+__name(_ClusterNotFoundException, "ClusterNotFoundException");
+var ClusterNotFoundException = _ClusterNotFoundException;
+var DeploymentControllerType = {
+  CODE_DEPLOY: "CODE_DEPLOY",
+  ECS: "ECS",
+  EXTERNAL: "EXTERNAL"
+};
+var LaunchType = {
+  EC2: "EC2",
+  EXTERNAL: "EXTERNAL",
+  FARGATE: "FARGATE"
+};
+var AssignPublicIp = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var PlacementConstraintType = {
+  DISTINCT_INSTANCE: "distinctInstance",
+  MEMBER_OF: "memberOf"
+};
+var PlacementStrategyType = {
+  BINPACK: "binpack",
+  RANDOM: "random",
+  SPREAD: "spread"
+};
+var PropagateTags = {
+  NONE: "NONE",
+  SERVICE: "SERVICE",
+  TASK_DEFINITION: "TASK_DEFINITION"
+};
+var SchedulingStrategy = {
+  DAEMON: "DAEMON",
+  REPLICA: "REPLICA"
+};
+var LogDriver = {
+  AWSFIRELENS: "awsfirelens",
+  AWSLOGS: "awslogs",
+  FLUENTD: "fluentd",
+  GELF: "gelf",
+  JOURNALD: "journald",
+  JSON_FILE: "json-file",
+  SPLUNK: "splunk",
+  SYSLOG: "syslog"
+};
+var TaskFilesystemType = {
+  EXT3: "ext3",
+  EXT4: "ext4",
+  XFS: "xfs"
+};
+var EBSResourceType = {
+  VOLUME: "volume"
+};
+var DeploymentRolloutState = {
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS"
+};
+var ScaleUnit = {
+  PERCENT: "PERCENT"
+};
+var StabilityStatus = {
+  STABILIZING: "STABILIZING",
+  STEADY_STATE: "STEADY_STATE"
+};
+var _PlatformTaskDefinitionIncompatibilityException = class _PlatformTaskDefinitionIncompatibilityException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PlatformTaskDefinitionIncompatibilityException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PlatformTaskDefinitionIncompatibilityException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PlatformTaskDefinitionIncompatibilityException.prototype);
+  }
+};
+__name(_PlatformTaskDefinitionIncompatibilityException, "PlatformTaskDefinitionIncompatibilityException");
+var PlatformTaskDefinitionIncompatibilityException = _PlatformTaskDefinitionIncompatibilityException;
+var _PlatformUnknownException = class _PlatformUnknownException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PlatformUnknownException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PlatformUnknownException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PlatformUnknownException.prototype);
+  }
+};
+__name(_PlatformUnknownException, "PlatformUnknownException");
+var PlatformUnknownException = _PlatformUnknownException;
+var _UnsupportedFeatureException = class _UnsupportedFeatureException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedFeatureException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedFeatureException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedFeatureException.prototype);
+  }
+};
+__name(_UnsupportedFeatureException, "UnsupportedFeatureException");
+var UnsupportedFeatureException = _UnsupportedFeatureException;
+var _ServiceNotActiveException = class _ServiceNotActiveException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceNotActiveException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceNotActiveException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceNotActiveException.prototype);
+  }
+};
+__name(_ServiceNotActiveException, "ServiceNotActiveException");
+var ServiceNotActiveException = _ServiceNotActiveException;
+var _ServiceNotFoundException = class _ServiceNotFoundException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceNotFoundException.prototype);
+  }
+};
+__name(_ServiceNotFoundException, "ServiceNotFoundException");
+var ServiceNotFoundException = _ServiceNotFoundException;
+var SettingName = {
+  AWSVPC_TRUNKING: "awsvpcTrunking",
+  CONTAINER_INSIGHTS: "containerInsights",
+  CONTAINER_INSTANCE_LONG_ARN_FORMAT: "containerInstanceLongArnFormat",
+  FARGATE_FIPS_MODE: "fargateFIPSMode",
+  FARGATE_TASK_RETIREMENT_WAIT_PERIOD: "fargateTaskRetirementWaitPeriod",
+  GUARD_DUTY_ACTIVATE: "guardDutyActivate",
+  SERVICE_LONG_ARN_FORMAT: "serviceLongArnFormat",
+  TAG_RESOURCE_AUTHORIZATION: "tagResourceAuthorization",
+  TASK_LONG_ARN_FORMAT: "taskLongArnFormat"
+};
+var SettingType = {
+  AWS_MANAGED: "aws_managed",
+  USER: "user"
+};
+var TargetType = {
+  CONTAINER_INSTANCE: "container-instance"
+};
+var _TargetNotFoundException = class _TargetNotFoundException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TargetNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TargetNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TargetNotFoundException.prototype);
+  }
+};
+__name(_TargetNotFoundException, "TargetNotFoundException");
+var TargetNotFoundException = _TargetNotFoundException;
+var _ClusterContainsContainerInstancesException = class _ClusterContainsContainerInstancesException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ClusterContainsContainerInstancesException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ClusterContainsContainerInstancesException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ClusterContainsContainerInstancesException.prototype);
+  }
+};
+__name(_ClusterContainsContainerInstancesException, "ClusterContainsContainerInstancesException");
+var ClusterContainsContainerInstancesException = _ClusterContainsContainerInstancesException;
+var _ClusterContainsServicesException = class _ClusterContainsServicesException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ClusterContainsServicesException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ClusterContainsServicesException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ClusterContainsServicesException.prototype);
+  }
+};
+__name(_ClusterContainsServicesException, "ClusterContainsServicesException");
+var ClusterContainsServicesException = _ClusterContainsServicesException;
+var _ClusterContainsTasksException = class _ClusterContainsTasksException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ClusterContainsTasksException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ClusterContainsTasksException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ClusterContainsTasksException.prototype);
+  }
+};
+__name(_ClusterContainsTasksException, "ClusterContainsTasksException");
+var ClusterContainsTasksException = _ClusterContainsTasksException;
+var Compatibility = {
+  EC2: "EC2",
+  EXTERNAL: "EXTERNAL",
+  FARGATE: "FARGATE"
+};
+var ContainerCondition = {
+  COMPLETE: "COMPLETE",
+  HEALTHY: "HEALTHY",
+  START: "START",
+  SUCCESS: "SUCCESS"
+};
+var EnvironmentFileType = {
+  S3: "s3"
+};
+var FirelensConfigurationType = {
+  FLUENTBIT: "fluentbit",
+  FLUENTD: "fluentd"
+};
+var DeviceCgroupPermission = {
+  MKNOD: "mknod",
+  READ: "read",
+  WRITE: "write"
+};
+var ApplicationProtocol = {
+  GRPC: "grpc",
+  HTTP: "http",
+  HTTP2: "http2"
+};
+var TransportProtocol = {
+  TCP: "tcp",
+  UDP: "udp"
+};
+var ResourceType = {
+  GPU: "GPU",
+  INFERENCE_ACCELERATOR: "InferenceAccelerator"
+};
+var UlimitName = {
+  CORE: "core",
+  CPU: "cpu",
+  DATA: "data",
+  FSIZE: "fsize",
+  LOCKS: "locks",
+  MEMLOCK: "memlock",
+  MSGQUEUE: "msgqueue",
+  NICE: "nice",
+  NOFILE: "nofile",
+  NPROC: "nproc",
+  RSS: "rss",
+  RTPRIO: "rtprio",
+  RTTIME: "rttime",
+  SIGPENDING: "sigpending",
+  STACK: "stack"
+};
+var IpcMode = {
+  HOST: "host",
+  NONE: "none",
+  TASK: "task"
+};
+var NetworkMode = {
+  AWSVPC: "awsvpc",
+  BRIDGE: "bridge",
+  HOST: "host",
+  NONE: "none"
+};
+var PidMode = {
+  HOST: "host",
+  TASK: "task"
+};
+var TaskDefinitionPlacementConstraintType = {
+  MEMBER_OF: "memberOf"
+};
+var ProxyConfigurationType = {
+  APPMESH: "APPMESH"
+};
+var CPUArchitecture = {
+  ARM64: "ARM64",
+  X86_64: "X86_64"
+};
+var OSFamily = {
+  LINUX: "LINUX",
+  WINDOWS_SERVER_2004_CORE: "WINDOWS_SERVER_2004_CORE",
+  WINDOWS_SERVER_2016_FULL: "WINDOWS_SERVER_2016_FULL",
+  WINDOWS_SERVER_2019_CORE: "WINDOWS_SERVER_2019_CORE",
+  WINDOWS_SERVER_2019_FULL: "WINDOWS_SERVER_2019_FULL",
+  WINDOWS_SERVER_2022_CORE: "WINDOWS_SERVER_2022_CORE",
+  WINDOWS_SERVER_2022_FULL: "WINDOWS_SERVER_2022_FULL",
+  WINDOWS_SERVER_20H2_CORE: "WINDOWS_SERVER_20H2_CORE"
+};
+var TaskDefinitionStatus = {
+  ACTIVE: "ACTIVE",
+  DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
+  INACTIVE: "INACTIVE"
+};
+var Scope = {
+  SHARED: "shared",
+  TASK: "task"
+};
+var EFSAuthorizationConfigIAM = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var EFSTransitEncryption = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var _TaskSetNotFoundException = class _TaskSetNotFoundException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TaskSetNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TaskSetNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TaskSetNotFoundException.prototype);
+  }
+};
+__name(_TaskSetNotFoundException, "TaskSetNotFoundException");
+var TaskSetNotFoundException = _TaskSetNotFoundException;
+var InstanceHealthCheckState = {
+  IMPAIRED: "IMPAIRED",
+  INITIALIZING: "INITIALIZING",
+  INSUFFICIENT_DATA: "INSUFFICIENT_DATA",
+  OK: "OK"
+};
+var InstanceHealthCheckType = {
+  CONTAINER_RUNTIME: "CONTAINER_RUNTIME"
+};
+var CapacityProviderField = {
+  TAGS: "TAGS"
+};
+var ClusterField = {
+  ATTACHMENTS: "ATTACHMENTS",
+  CONFIGURATIONS: "CONFIGURATIONS",
+  SETTINGS: "SETTINGS",
+  STATISTICS: "STATISTICS",
+  TAGS: "TAGS"
+};
+var ContainerInstanceField = {
+  CONTAINER_INSTANCE_HEALTH: "CONTAINER_INSTANCE_HEALTH",
+  TAGS: "TAGS"
+};
+var ServiceField = {
+  TAGS: "TAGS"
+};
+var TaskDefinitionField = {
+  TAGS: "TAGS"
+};
+var TaskField = {
+  TAGS: "TAGS"
+};
+var Connectivity = {
+  CONNECTED: "CONNECTED",
+  DISCONNECTED: "DISCONNECTED"
+};
+var HealthStatus = {
+  HEALTHY: "HEALTHY",
+  UNHEALTHY: "UNHEALTHY",
+  UNKNOWN: "UNKNOWN"
+};
+var ManagedAgentName = {
+  ExecuteCommandAgent: "ExecuteCommandAgent"
+};
+var TaskStopCode = {
+  ESSENTIAL_CONTAINER_EXITED: "EssentialContainerExited",
+  SERVICE_SCHEDULER_INITIATED: "ServiceSchedulerInitiated",
+  SPOT_INTERRUPTION: "SpotInterruption",
+  TASK_FAILED_TO_START: "TaskFailedToStart",
+  TERMINATION_NOTICE: "TerminationNotice",
+  USER_INITIATED: "UserInitiated"
+};
+var TaskSetField = {
+  TAGS: "TAGS"
+};
+var _TargetNotConnectedException = class _TargetNotConnectedException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TargetNotConnectedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TargetNotConnectedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TargetNotConnectedException.prototype);
+  }
+};
+__name(_TargetNotConnectedException, "TargetNotConnectedException");
+var TargetNotConnectedException = _TargetNotConnectedException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var ContainerInstanceStatus = {
+  ACTIVE: "ACTIVE",
+  DEREGISTERING: "DEREGISTERING",
+  DRAINING: "DRAINING",
+  REGISTERING: "REGISTERING",
+  REGISTRATION_FAILED: "REGISTRATION_FAILED"
+};
+var TaskDefinitionFamilyStatus = {
+  ACTIVE: "ACTIVE",
+  ALL: "ALL",
+  INACTIVE: "INACTIVE"
+};
+var SortOrder = {
+  ASC: "ASC",
+  DESC: "DESC"
+};
+var DesiredStatus = {
+  PENDING: "PENDING",
+  RUNNING: "RUNNING",
+  STOPPED: "STOPPED"
+};
+var _AttributeLimitExceededException = class _AttributeLimitExceededException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AttributeLimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AttributeLimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AttributeLimitExceededException.prototype);
+  }
+};
+__name(_AttributeLimitExceededException, "AttributeLimitExceededException");
+var AttributeLimitExceededException = _AttributeLimitExceededException;
+var _ResourceInUseException = class _ResourceInUseException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceInUseException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceInUseException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceInUseException.prototype);
+  }
+};
+__name(_ResourceInUseException, "ResourceInUseException");
+var ResourceInUseException = _ResourceInUseException;
+var PlatformDeviceType = {
+  GPU: "GPU"
+};
+var _BlockedException = class _BlockedException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BlockedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BlockedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BlockedException.prototype);
+  }
+};
+__name(_BlockedException, "BlockedException");
+var BlockedException = _BlockedException;
+var _ConflictException = class _ConflictException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.resourceIds = opts.resourceIds;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _MissingVersionException = class _MissingVersionException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MissingVersionException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MissingVersionException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MissingVersionException.prototype);
+  }
+};
+__name(_MissingVersionException, "MissingVersionException");
+var MissingVersionException = _MissingVersionException;
+var _NoUpdateAvailableException = class _NoUpdateAvailableException extends ECSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NoUpdateAvailableException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NoUpdateAvailableException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NoUpdateAvailableException.prototype);
+  }
+};
+__name(_NoUpdateAvailableException, "NoUpdateAvailableException");
+var NoUpdateAvailableException = _NoUpdateAvailableException;
+var SessionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.tokenValue && { tokenValue: import_smithy_client.SENSITIVE_STRING }
+}), "SessionFilterSensitiveLog");
+var ExecuteCommandResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.session && { session: SessionFilterSensitiveLog(obj.session) }
+}), "ExecuteCommandResponseFilterSensitiveLog");
+
+// src/protocols/Aws_json1_1.ts
+var se_CreateCapacityProviderCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateCapacityProvider");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateCapacityProviderCommand");
+var se_CreateClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateCluster");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateClusterCommand");
+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_CreateTaskSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateTaskSet");
+  let body;
+  body = JSON.stringify(se_CreateTaskSetRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateTaskSetCommand");
+var se_DeleteAccountSettingCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteAccountSetting");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteAccountSettingCommand");
+var se_DeleteAttributesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteAttributes");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteAttributesCommand");
+var se_DeleteCapacityProviderCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteCapacityProvider");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteCapacityProviderCommand");
+var se_DeleteClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteCluster");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteClusterCommand");
+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_DeleteTaskDefinitionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteTaskDefinitions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteTaskDefinitionsCommand");
+var se_DeleteTaskSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteTaskSet");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteTaskSetCommand");
+var se_DeregisterContainerInstanceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeregisterContainerInstance");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeregisterContainerInstanceCommand");
+var se_DeregisterTaskDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeregisterTaskDefinition");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeregisterTaskDefinitionCommand");
+var se_DescribeCapacityProvidersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeCapacityProviders");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeCapacityProvidersCommand");
+var se_DescribeClustersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeClusters");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeClustersCommand");
+var se_DescribeContainerInstancesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeContainerInstances");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeContainerInstancesCommand");
+var se_DescribeServicesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeServices");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeServicesCommand");
+var se_DescribeTaskDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeTaskDefinition");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeTaskDefinitionCommand");
+var se_DescribeTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeTasks");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeTasksCommand");
+var se_DescribeTaskSetsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeTaskSets");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeTaskSetsCommand");
+var se_DiscoverPollEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DiscoverPollEndpoint");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DiscoverPollEndpointCommand");
+var se_ExecuteCommandCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ExecuteCommand");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ExecuteCommandCommand");
+var se_GetTaskProtectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetTaskProtection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetTaskProtectionCommand");
+var se_ListAccountSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListAccountSettings");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListAccountSettingsCommand");
+var se_ListAttributesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListAttributes");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListAttributesCommand");
+var se_ListClustersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListClusters");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListClustersCommand");
+var se_ListContainerInstancesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListContainerInstances");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListContainerInstancesCommand");
+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_ListServicesByNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListServicesByNamespace");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListServicesByNamespaceCommand");
+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_ListTaskDefinitionFamiliesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTaskDefinitionFamilies");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTaskDefinitionFamiliesCommand");
+var se_ListTaskDefinitionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTaskDefinitions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTaskDefinitionsCommand");
+var se_ListTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTasks");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTasksCommand");
+var se_PutAccountSettingCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutAccountSetting");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutAccountSettingCommand");
+var se_PutAccountSettingDefaultCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutAccountSettingDefault");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutAccountSettingDefaultCommand");
+var se_PutAttributesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutAttributes");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutAttributesCommand");
+var se_PutClusterCapacityProvidersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutClusterCapacityProviders");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutClusterCapacityProvidersCommand");
+var se_RegisterContainerInstanceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RegisterContainerInstance");
+  let body;
+  body = JSON.stringify(se_RegisterContainerInstanceRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RegisterContainerInstanceCommand");
+var se_RegisterTaskDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RegisterTaskDefinition");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RegisterTaskDefinitionCommand");
+var se_RunTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RunTask");
+  let body;
+  body = JSON.stringify(se_RunTaskRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RunTaskCommand");
+var se_StartTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartTask");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartTaskCommand");
+var se_StopTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StopTask");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StopTaskCommand");
+var se_SubmitAttachmentStateChangesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SubmitAttachmentStateChanges");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SubmitAttachmentStateChangesCommand");
+var se_SubmitContainerStateChangeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SubmitContainerStateChange");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SubmitContainerStateChangeCommand");
+var se_SubmitTaskStateChangeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SubmitTaskStateChange");
+  let body;
+  body = JSON.stringify(se_SubmitTaskStateChangeRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SubmitTaskStateChangeCommand");
+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_UpdateCapacityProviderCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateCapacityProvider");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateCapacityProviderCommand");
+var se_UpdateClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateCluster");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateClusterCommand");
+var se_UpdateClusterSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateClusterSettings");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateClusterSettingsCommand");
+var se_UpdateContainerAgentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateContainerAgent");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateContainerAgentCommand");
+var se_UpdateContainerInstancesStateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateContainerInstancesState");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateContainerInstancesStateCommand");
+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_UpdateServicePrimaryTaskSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateServicePrimaryTaskSet");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateServicePrimaryTaskSetCommand");
+var se_UpdateTaskProtectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateTaskProtection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateTaskProtectionCommand");
+var se_UpdateTaskSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateTaskSet");
+  let body;
+  body = JSON.stringify(se_UpdateTaskSetRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateTaskSetCommand");
+var de_CreateCapacityProviderCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateCapacityProviderCommand");
+var de_CreateClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateClusterCommand");
+var de_CreateServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_CreateServiceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateServiceCommand");
+var de_CreateTaskSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_CreateTaskSetResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateTaskSetCommand");
+var de_DeleteAccountSettingCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteAccountSettingCommand");
+var de_DeleteAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteAttributesCommand");
+var de_DeleteCapacityProviderCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteCapacityProviderCommand");
+var de_DeleteClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteClusterCommand");
+var de_DeleteServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_DeleteServiceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteServiceCommand");
+var de_DeleteTaskDefinitionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_DeleteTaskDefinitionsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteTaskDefinitionsCommand");
+var de_DeleteTaskSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_DeleteTaskSetResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteTaskSetCommand");
+var de_DeregisterContainerInstanceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_DeregisterContainerInstanceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeregisterContainerInstanceCommand");
+var de_DeregisterTaskDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_DeregisterTaskDefinitionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeregisterTaskDefinitionCommand");
+var de_DescribeCapacityProvidersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeCapacityProvidersCommand");
+var de_DescribeClustersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeClustersCommand");
+var de_DescribeContainerInstancesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_DescribeContainerInstancesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeContainerInstancesCommand");
+var de_DescribeServicesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_DescribeServicesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeServicesCommand");
+var de_DescribeTaskDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_DescribeTaskDefinitionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeTaskDefinitionCommand");
+var de_DescribeTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_DescribeTasksResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeTasksCommand");
+var de_DescribeTaskSetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_DescribeTaskSetsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeTaskSetsCommand");
+var de_DiscoverPollEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DiscoverPollEndpointCommand");
+var de_ExecuteCommandCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ExecuteCommandCommand");
+var de_GetTaskProtectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_GetTaskProtectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetTaskProtectionCommand");
+var de_ListAccountSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListAccountSettingsCommand");
+var de_ListAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListAttributesCommand");
+var de_ListClustersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListClustersCommand");
+var de_ListContainerInstancesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListContainerInstancesCommand");
+var de_ListServicesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListServicesCommand");
+var de_ListServicesByNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListServicesByNamespaceCommand");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsForResourceCommand");
+var de_ListTaskDefinitionFamiliesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTaskDefinitionFamiliesCommand");
+var de_ListTaskDefinitionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTaskDefinitionsCommand");
+var de_ListTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTasksCommand");
+var de_PutAccountSettingCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutAccountSettingCommand");
+var de_PutAccountSettingDefaultCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutAccountSettingDefaultCommand");
+var de_PutAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutAttributesCommand");
+var de_PutClusterCapacityProvidersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutClusterCapacityProvidersCommand");
+var de_RegisterContainerInstanceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_RegisterContainerInstanceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RegisterContainerInstanceCommand");
+var de_RegisterTaskDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_RegisterTaskDefinitionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RegisterTaskDefinitionCommand");
+var de_RunTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_RunTaskResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RunTaskCommand");
+var de_StartTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_StartTaskResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartTaskCommand");
+var de_StopTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_StopTaskResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StopTaskCommand");
+var de_SubmitAttachmentStateChangesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SubmitAttachmentStateChangesCommand");
+var de_SubmitContainerStateChangeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SubmitContainerStateChangeCommand");
+var de_SubmitTaskStateChangeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SubmitTaskStateChangeCommand");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UpdateCapacityProviderCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateCapacityProviderCommand");
+var de_UpdateClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateClusterCommand");
+var de_UpdateClusterSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateClusterSettingsCommand");
+var de_UpdateContainerAgentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_UpdateContainerAgentResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateContainerAgentCommand");
+var de_UpdateContainerInstancesStateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_UpdateContainerInstancesStateResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateContainerInstancesStateCommand");
+var de_UpdateServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_UpdateServiceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateServiceCommand");
+var de_UpdateServicePrimaryTaskSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_UpdateServicePrimaryTaskSetResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateServicePrimaryTaskSetCommand");
+var de_UpdateTaskProtectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_UpdateTaskProtectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateTaskProtectionCommand");
+var de_UpdateTaskSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_UpdateTaskSetResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateTaskSetCommand");
+var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
+  };
+  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.ecs#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.ecs#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.ecs#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecs#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "UpdateInProgressException":
+    case "com.amazonaws.ecs#UpdateInProgressException":
+      throw await de_UpdateInProgressExceptionRes(parsedOutput, context);
+    case "NamespaceNotFoundException":
+    case "com.amazonaws.ecs#NamespaceNotFoundException":
+      throw await de_NamespaceNotFoundExceptionRes(parsedOutput, context);
+    case "AccessDeniedException":
+    case "com.amazonaws.ecs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ClusterNotFoundException":
+    case "com.amazonaws.ecs#ClusterNotFoundException":
+      throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
+    case "PlatformTaskDefinitionIncompatibilityException":
+    case "com.amazonaws.ecs#PlatformTaskDefinitionIncompatibilityException":
+      throw await de_PlatformTaskDefinitionIncompatibilityExceptionRes(parsedOutput, context);
+    case "PlatformUnknownException":
+    case "com.amazonaws.ecs#PlatformUnknownException":
+      throw await de_PlatformUnknownExceptionRes(parsedOutput, context);
+    case "UnsupportedFeatureException":
+    case "com.amazonaws.ecs#UnsupportedFeatureException":
+      throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
+    case "ServiceNotActiveException":
+    case "com.amazonaws.ecs#ServiceNotActiveException":
+      throw await de_ServiceNotActiveExceptionRes(parsedOutput, context);
+    case "ServiceNotFoundException":
+    case "com.amazonaws.ecs#ServiceNotFoundException":
+      throw await de_ServiceNotFoundExceptionRes(parsedOutput, context);
+    case "TargetNotFoundException":
+    case "com.amazonaws.ecs#TargetNotFoundException":
+      throw await de_TargetNotFoundExceptionRes(parsedOutput, context);
+    case "ClusterContainsContainerInstancesException":
+    case "com.amazonaws.ecs#ClusterContainsContainerInstancesException":
+      throw await de_ClusterContainsContainerInstancesExceptionRes(parsedOutput, context);
+    case "ClusterContainsServicesException":
+    case "com.amazonaws.ecs#ClusterContainsServicesException":
+      throw await de_ClusterContainsServicesExceptionRes(parsedOutput, context);
+    case "ClusterContainsTasksException":
+    case "com.amazonaws.ecs#ClusterContainsTasksException":
+      throw await de_ClusterContainsTasksExceptionRes(parsedOutput, context);
+    case "TaskSetNotFoundException":
+    case "com.amazonaws.ecs#TaskSetNotFoundException":
+      throw await de_TaskSetNotFoundExceptionRes(parsedOutput, context);
+    case "TargetNotConnectedException":
+    case "com.amazonaws.ecs#TargetNotConnectedException":
+      throw await de_TargetNotConnectedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ecs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "AttributeLimitExceededException":
+    case "com.amazonaws.ecs#AttributeLimitExceededException":
+      throw await de_AttributeLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.ecs#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "BlockedException":
+    case "com.amazonaws.ecs#BlockedException":
+      throw await de_BlockedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ecs#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "MissingVersionException":
+    case "com.amazonaws.ecs#MissingVersionException":
+      throw await de_MissingVersionExceptionRes(parsedOutput, context);
+    case "NoUpdateAvailableException":
+    case "com.amazonaws.ecs#NoUpdateAvailableException":
+      throw await de_NoUpdateAvailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CommandError");
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AccessDeniedExceptionRes");
+var de_AttributeLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AttributeLimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AttributeLimitExceededExceptionRes");
+var de_BlockedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new BlockedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_BlockedExceptionRes");
+var de_ClientExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ClientException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ClientExceptionRes");
+var de_ClusterContainsContainerInstancesExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ClusterContainsContainerInstancesException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ClusterContainsContainerInstancesExceptionRes");
+var de_ClusterContainsServicesExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ClusterContainsServicesException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ClusterContainsServicesExceptionRes");
+var de_ClusterContainsTasksExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ClusterContainsTasksException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ClusterContainsTasksExceptionRes");
+var de_ClusterNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ClusterNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ClusterNotFoundExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ConflictExceptionRes");
+var de_InvalidParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidParameterException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidParameterExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LimitExceededExceptionRes");
+var de_MissingVersionExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new MissingVersionException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_MissingVersionExceptionRes");
+var de_NamespaceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new NamespaceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_NamespaceNotFoundExceptionRes");
+var de_NoUpdateAvailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new NoUpdateAvailableException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_NoUpdateAvailableExceptionRes");
+var de_PlatformTaskDefinitionIncompatibilityExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new PlatformTaskDefinitionIncompatibilityException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_PlatformTaskDefinitionIncompatibilityExceptionRes");
+var de_PlatformUnknownExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new PlatformUnknownException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_PlatformUnknownExceptionRes");
+var de_ResourceInUseExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceInUseException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceInUseExceptionRes");
+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_ServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServerExceptionRes");
+var de_ServiceNotActiveExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceNotActiveException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceNotActiveExceptionRes");
+var de_ServiceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceNotFoundExceptionRes");
+var de_TargetNotConnectedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TargetNotConnectedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TargetNotConnectedExceptionRes");
+var de_TargetNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TargetNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TargetNotFoundExceptionRes");
+var de_TaskSetNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TaskSetNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TaskSetNotFoundExceptionRes");
+var de_UnsupportedFeatureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnsupportedFeatureException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnsupportedFeatureExceptionRes");
+var de_UpdateInProgressExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UpdateInProgressException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UpdateInProgressExceptionRes");
+var se_CreateTaskSetRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    capacityProviderStrategy: import_smithy_client._json,
+    clientToken: [],
+    cluster: [],
+    externalId: [],
+    launchType: [],
+    loadBalancers: import_smithy_client._json,
+    networkConfiguration: import_smithy_client._json,
+    platformVersion: [],
+    scale: (_) => se_Scale(_, context),
+    service: [],
+    serviceRegistries: import_smithy_client._json,
+    tags: import_smithy_client._json,
+    taskDefinition: []
+  });
+}, "se_CreateTaskSetRequest");
+var se_RegisterContainerInstanceRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    attributes: import_smithy_client._json,
+    cluster: [],
+    containerInstanceArn: [],
+    instanceIdentityDocument: [],
+    instanceIdentityDocumentSignature: [],
+    platformDevices: import_smithy_client._json,
+    tags: import_smithy_client._json,
+    totalResources: (_) => se_Resources(_, context),
+    versionInfo: import_smithy_client._json
+  });
+}, "se_RegisterContainerInstanceRequest");
+var se_Resource = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    doubleValue: import_smithy_client.serializeFloat,
+    integerValue: [],
+    longValue: [],
+    name: [],
+    stringSetValue: import_smithy_client._json,
+    type: []
+  });
+}, "se_Resource");
+var se_Resources = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Resource(entry, context);
+  });
+}, "se_Resources");
+var se_RunTaskRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    capacityProviderStrategy: import_smithy_client._json,
+    clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+    cluster: [],
+    count: [],
+    enableECSManagedTags: [],
+    enableExecuteCommand: [],
+    group: [],
+    launchType: [],
+    networkConfiguration: import_smithy_client._json,
+    overrides: import_smithy_client._json,
+    placementConstraints: import_smithy_client._json,
+    placementStrategy: import_smithy_client._json,
+    platformVersion: [],
+    propagateTags: [],
+    referenceId: [],
+    startedBy: [],
+    tags: import_smithy_client._json,
+    taskDefinition: [],
+    volumeConfigurations: import_smithy_client._json
+  });
+}, "se_RunTaskRequest");
+var se_Scale = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    unit: [],
+    value: import_smithy_client.serializeFloat
+  });
+}, "se_Scale");
+var se_SubmitTaskStateChangeRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    attachments: import_smithy_client._json,
+    cluster: [],
+    containers: import_smithy_client._json,
+    executionStoppedAt: (_) => _.getTime() / 1e3,
+    managedAgents: import_smithy_client._json,
+    pullStartedAt: (_) => _.getTime() / 1e3,
+    pullStoppedAt: (_) => _.getTime() / 1e3,
+    reason: [],
+    status: [],
+    task: []
+  });
+}, "se_SubmitTaskStateChangeRequest");
+var se_UpdateTaskSetRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    cluster: [],
+    scale: (_) => se_Scale(_, context),
+    service: [],
+    taskSet: []
+  });
+}, "se_UpdateTaskSetRequest");
+var de_Container = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    containerArn: import_smithy_client.expectString,
+    cpu: import_smithy_client.expectString,
+    exitCode: import_smithy_client.expectInt32,
+    gpuIds: import_smithy_client._json,
+    healthStatus: import_smithy_client.expectString,
+    image: import_smithy_client.expectString,
+    imageDigest: import_smithy_client.expectString,
+    lastStatus: import_smithy_client.expectString,
+    managedAgents: (_) => de_ManagedAgents(_, context),
+    memory: import_smithy_client.expectString,
+    memoryReservation: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    networkBindings: import_smithy_client._json,
+    networkInterfaces: import_smithy_client._json,
+    reason: import_smithy_client.expectString,
+    runtimeId: import_smithy_client.expectString,
+    taskArn: import_smithy_client.expectString
+  });
+}, "de_Container");
+var de_ContainerInstance = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    agentConnected: import_smithy_client.expectBoolean,
+    agentUpdateStatus: import_smithy_client.expectString,
+    attachments: import_smithy_client._json,
+    attributes: import_smithy_client._json,
+    capacityProviderName: import_smithy_client.expectString,
+    containerInstanceArn: import_smithy_client.expectString,
+    ec2InstanceId: import_smithy_client.expectString,
+    healthStatus: (_) => de_ContainerInstanceHealthStatus(_, context),
+    pendingTasksCount: import_smithy_client.expectInt32,
+    registeredAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    registeredResources: (_) => de_Resources(_, context),
+    remainingResources: (_) => de_Resources(_, context),
+    runningTasksCount: import_smithy_client.expectInt32,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    tags: import_smithy_client._json,
+    version: import_smithy_client.expectLong,
+    versionInfo: import_smithy_client._json
+  });
+}, "de_ContainerInstance");
+var de_ContainerInstanceHealthStatus = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    details: (_) => de_InstanceHealthCheckResultList(_, context),
+    overallStatus: import_smithy_client.expectString
+  });
+}, "de_ContainerInstanceHealthStatus");
+var de_ContainerInstances = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ContainerInstance(entry, context);
+  });
+  return retVal;
+}, "de_ContainerInstances");
+var de_Containers = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Container(entry, context);
+  });
+  return retVal;
+}, "de_Containers");
+var de_CreateServiceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    service: (_) => de_Service(_, context)
+  });
+}, "de_CreateServiceResponse");
+var de_CreateTaskSetResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    taskSet: (_) => de_TaskSet(_, context)
+  });
+}, "de_CreateTaskSetResponse");
+var de_DeleteServiceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    service: (_) => de_Service(_, context)
+  });
+}, "de_DeleteServiceResponse");
+var de_DeleteTaskDefinitionsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    failures: import_smithy_client._json,
+    taskDefinitions: (_) => de_TaskDefinitionList(_, context)
+  });
+}, "de_DeleteTaskDefinitionsResponse");
+var de_DeleteTaskSetResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    taskSet: (_) => de_TaskSet(_, context)
+  });
+}, "de_DeleteTaskSetResponse");
+var de_Deployment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    capacityProviderStrategy: import_smithy_client._json,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    desiredCount: import_smithy_client.expectInt32,
+    failedTasks: import_smithy_client.expectInt32,
+    fargateEphemeralStorage: import_smithy_client._json,
+    id: import_smithy_client.expectString,
+    launchType: import_smithy_client.expectString,
+    networkConfiguration: import_smithy_client._json,
+    pendingCount: import_smithy_client.expectInt32,
+    platformFamily: import_smithy_client.expectString,
+    platformVersion: import_smithy_client.expectString,
+    rolloutState: import_smithy_client.expectString,
+    rolloutStateReason: import_smithy_client.expectString,
+    runningCount: import_smithy_client.expectInt32,
+    serviceConnectConfiguration: import_smithy_client._json,
+    serviceConnectResources: import_smithy_client._json,
+    status: import_smithy_client.expectString,
+    taskDefinition: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    volumeConfigurations: import_smithy_client._json
+  });
+}, "de_Deployment");
+var de_Deployments = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Deployment(entry, context);
+  });
+  return retVal;
+}, "de_Deployments");
+var de_DeregisterContainerInstanceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    containerInstance: (_) => de_ContainerInstance(_, context)
+  });
+}, "de_DeregisterContainerInstanceResponse");
+var de_DeregisterTaskDefinitionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    taskDefinition: (_) => de_TaskDefinition(_, context)
+  });
+}, "de_DeregisterTaskDefinitionResponse");
+var de_DescribeContainerInstancesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    containerInstances: (_) => de_ContainerInstances(_, context),
+    failures: import_smithy_client._json
+  });
+}, "de_DescribeContainerInstancesResponse");
+var de_DescribeServicesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    failures: import_smithy_client._json,
+    services: (_) => de_Services(_, context)
+  });
+}, "de_DescribeServicesResponse");
+var de_DescribeTaskDefinitionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    tags: import_smithy_client._json,
+    taskDefinition: (_) => de_TaskDefinition(_, context)
+  });
+}, "de_DescribeTaskDefinitionResponse");
+var de_DescribeTaskSetsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    failures: import_smithy_client._json,
+    taskSets: (_) => de_TaskSets(_, context)
+  });
+}, "de_DescribeTaskSetsResponse");
+var de_DescribeTasksResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    failures: import_smithy_client._json,
+    tasks: (_) => de_Tasks(_, context)
+  });
+}, "de_DescribeTasksResponse");
+var de_GetTaskProtectionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    failures: import_smithy_client._json,
+    protectedTasks: (_) => de_ProtectedTasks(_, context)
+  });
+}, "de_GetTaskProtectionResponse");
+var de_InstanceHealthCheckResult = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    lastStatusChange: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lastUpdated: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    status: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+}, "de_InstanceHealthCheckResult");
+var de_InstanceHealthCheckResultList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_InstanceHealthCheckResult(entry, context);
+  });
+  return retVal;
+}, "de_InstanceHealthCheckResultList");
+var de_ManagedAgent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    lastStartedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lastStatus: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    reason: import_smithy_client.expectString
+  });
+}, "de_ManagedAgent");
+var de_ManagedAgents = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ManagedAgent(entry, context);
+  });
+  return retVal;
+}, "de_ManagedAgents");
+var de_ProtectedTask = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    expirationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    protectionEnabled: import_smithy_client.expectBoolean,
+    taskArn: import_smithy_client.expectString
+  });
+}, "de_ProtectedTask");
+var de_ProtectedTasks = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ProtectedTask(entry, context);
+  });
+  return retVal;
+}, "de_ProtectedTasks");
+var de_RegisterContainerInstanceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    containerInstance: (_) => de_ContainerInstance(_, context)
+  });
+}, "de_RegisterContainerInstanceResponse");
+var de_RegisterTaskDefinitionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    tags: import_smithy_client._json,
+    taskDefinition: (_) => de_TaskDefinition(_, context)
+  });
+}, "de_RegisterTaskDefinitionResponse");
+var de_Resource = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    doubleValue: import_smithy_client.limitedParseDouble,
+    integerValue: import_smithy_client.expectInt32,
+    longValue: import_smithy_client.expectLong,
+    name: import_smithy_client.expectString,
+    stringSetValue: import_smithy_client._json,
+    type: import_smithy_client.expectString
+  });
+}, "de_Resource");
+var de_Resources = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Resource(entry, context);
+  });
+  return retVal;
+}, "de_Resources");
+var de_RunTaskResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    failures: import_smithy_client._json,
+    tasks: (_) => de_Tasks(_, context)
+  });
+}, "de_RunTaskResponse");
+var de_Scale = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    unit: import_smithy_client.expectString,
+    value: import_smithy_client.limitedParseDouble
+  });
+}, "de_Scale");
+var de_Service = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    capacityProviderStrategy: import_smithy_client._json,
+    clusterArn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    createdBy: import_smithy_client.expectString,
+    deploymentConfiguration: import_smithy_client._json,
+    deploymentController: import_smithy_client._json,
+    deployments: (_) => de_Deployments(_, context),
+    desiredCount: import_smithy_client.expectInt32,
+    enableECSManagedTags: import_smithy_client.expectBoolean,
+    enableExecuteCommand: import_smithy_client.expectBoolean,
+    events: (_) => de_ServiceEvents(_, context),
+    healthCheckGracePeriodSeconds: import_smithy_client.expectInt32,
+    launchType: import_smithy_client.expectString,
+    loadBalancers: import_smithy_client._json,
+    networkConfiguration: import_smithy_client._json,
+    pendingCount: import_smithy_client.expectInt32,
+    placementConstraints: import_smithy_client._json,
+    placementStrategy: import_smithy_client._json,
+    platformFamily: import_smithy_client.expectString,
+    platformVersion: import_smithy_client.expectString,
+    propagateTags: import_smithy_client.expectString,
+    roleArn: import_smithy_client.expectString,
+    runningCount: import_smithy_client.expectInt32,
+    schedulingStrategy: import_smithy_client.expectString,
+    serviceArn: import_smithy_client.expectString,
+    serviceName: import_smithy_client.expectString,
+    serviceRegistries: import_smithy_client._json,
+    status: import_smithy_client.expectString,
+    tags: import_smithy_client._json,
+    taskDefinition: import_smithy_client.expectString,
+    taskSets: (_) => de_TaskSets(_, context)
+  });
+}, "de_Service");
+var de_ServiceEvent = /* @__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)(_))),
+    id: import_smithy_client.expectString,
+    message: import_smithy_client.expectString
+  });
+}, "de_ServiceEvent");
+var de_ServiceEvents = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ServiceEvent(entry, context);
+  });
+  return retVal;
+}, "de_ServiceEvents");
+var de_Services = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Service(entry, context);
+  });
+  return retVal;
+}, "de_Services");
+var de_StartTaskResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    failures: import_smithy_client._json,
+    tasks: (_) => de_Tasks(_, context)
+  });
+}, "de_StartTaskResponse");
+var de_StopTaskResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    task: (_) => de_Task(_, context)
+  });
+}, "de_StopTaskResponse");
+var de_Task = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    attachments: import_smithy_client._json,
+    attributes: import_smithy_client._json,
+    availabilityZone: import_smithy_client.expectString,
+    capacityProviderName: import_smithy_client.expectString,
+    clusterArn: import_smithy_client.expectString,
+    connectivity: import_smithy_client.expectString,
+    connectivityAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    containerInstanceArn: import_smithy_client.expectString,
+    containers: (_) => de_Containers(_, context),
+    cpu: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    desiredStatus: import_smithy_client.expectString,
+    enableExecuteCommand: import_smithy_client.expectBoolean,
+    ephemeralStorage: import_smithy_client._json,
+    executionStoppedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    fargateEphemeralStorage: import_smithy_client._json,
+    group: import_smithy_client.expectString,
+    healthStatus: import_smithy_client.expectString,
+    inferenceAccelerators: import_smithy_client._json,
+    lastStatus: import_smithy_client.expectString,
+    launchType: import_smithy_client.expectString,
+    memory: import_smithy_client.expectString,
+    overrides: import_smithy_client._json,
+    platformFamily: import_smithy_client.expectString,
+    platformVersion: import_smithy_client.expectString,
+    pullStartedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    pullStoppedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    startedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    startedBy: import_smithy_client.expectString,
+    stopCode: import_smithy_client.expectString,
+    stoppedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    stoppedReason: import_smithy_client.expectString,
+    stoppingAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    tags: import_smithy_client._json,
+    taskArn: import_smithy_client.expectString,
+    taskDefinitionArn: import_smithy_client.expectString,
+    version: import_smithy_client.expectLong
+  });
+}, "de_Task");
+var de_TaskDefinition = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    compatibilities: import_smithy_client._json,
+    containerDefinitions: import_smithy_client._json,
+    cpu: import_smithy_client.expectString,
+    deregisteredAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ephemeralStorage: import_smithy_client._json,
+    executionRoleArn: import_smithy_client.expectString,
+    family: import_smithy_client.expectString,
+    inferenceAccelerators: import_smithy_client._json,
+    ipcMode: import_smithy_client.expectString,
+    memory: import_smithy_client.expectString,
+    networkMode: import_smithy_client.expectString,
+    pidMode: import_smithy_client.expectString,
+    placementConstraints: import_smithy_client._json,
+    proxyConfiguration: import_smithy_client._json,
+    registeredAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    registeredBy: import_smithy_client.expectString,
+    requiresAttributes: import_smithy_client._json,
+    requiresCompatibilities: import_smithy_client._json,
+    revision: import_smithy_client.expectInt32,
+    runtimePlatform: import_smithy_client._json,
+    status: import_smithy_client.expectString,
+    taskDefinitionArn: import_smithy_client.expectString,
+    taskRoleArn: import_smithy_client.expectString,
+    volumes: import_smithy_client._json
+  });
+}, "de_TaskDefinition");
+var de_TaskDefinitionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_TaskDefinition(entry, context);
+  });
+  return retVal;
+}, "de_TaskDefinitionList");
+var de_Tasks = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Task(entry, context);
+  });
+  return retVal;
+}, "de_Tasks");
+var de_TaskSet = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    capacityProviderStrategy: import_smithy_client._json,
+    clusterArn: import_smithy_client.expectString,
+    computedDesiredCount: import_smithy_client.expectInt32,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    externalId: import_smithy_client.expectString,
+    fargateEphemeralStorage: import_smithy_client._json,
+    id: import_smithy_client.expectString,
+    launchType: import_smithy_client.expectString,
+    loadBalancers: import_smithy_client._json,
+    networkConfiguration: import_smithy_client._json,
+    pendingCount: import_smithy_client.expectInt32,
+    platformFamily: import_smithy_client.expectString,
+    platformVersion: import_smithy_client.expectString,
+    runningCount: import_smithy_client.expectInt32,
+    scale: (_) => de_Scale(_, context),
+    serviceArn: import_smithy_client.expectString,
+    serviceRegistries: import_smithy_client._json,
+    stabilityStatus: import_smithy_client.expectString,
+    stabilityStatusAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    startedBy: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    tags: import_smithy_client._json,
+    taskDefinition: import_smithy_client.expectString,
+    taskSetArn: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_TaskSet");
+var de_TaskSets = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_TaskSet(entry, context);
+  });
+  return retVal;
+}, "de_TaskSets");
+var de_UpdateContainerAgentResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    containerInstance: (_) => de_ContainerInstance(_, context)
+  });
+}, "de_UpdateContainerAgentResponse");
+var de_UpdateContainerInstancesStateResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    containerInstances: (_) => de_ContainerInstances(_, context),
+    failures: import_smithy_client._json
+  });
+}, "de_UpdateContainerInstancesStateResponse");
+var de_UpdateServicePrimaryTaskSetResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    taskSet: (_) => de_TaskSet(_, context)
+  });
+}, "de_UpdateServicePrimaryTaskSetResponse");
+var de_UpdateServiceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    service: (_) => de_Service(_, context)
+  });
+}, "de_UpdateServiceResponse");
+var de_UpdateTaskProtectionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    failures: import_smithy_client._json,
+    protectedTasks: (_) => de_ProtectedTasks(_, context)
+  });
+}, "de_UpdateTaskProtectionResponse");
+var de_UpdateTaskSetResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    taskSet: (_) => de_TaskSet(_, context)
+  });
+}, "de_UpdateTaskSetResponse");
+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 throwDefaultError = (0, import_smithy_client.withBaseException)(ECSServiceException);
+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.1",
+    "x-amz-target": `AmazonEC2ContainerServiceV20141113.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+
+// src/commands/CreateCapacityProviderCommand.ts
+var _CreateCapacityProviderCommand = class _CreateCapacityProviderCommand 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("AmazonEC2ContainerServiceV20141113", "CreateCapacityProvider", {}).n("ECSClient", "CreateCapacityProviderCommand").f(void 0, void 0).ser(se_CreateCapacityProviderCommand).de(de_CreateCapacityProviderCommand).build() {
+};
+__name(_CreateCapacityProviderCommand, "CreateCapacityProviderCommand");
+var CreateCapacityProviderCommand = _CreateCapacityProviderCommand;
+
+// src/commands/CreateClusterCommand.ts
+
+
+
+var _CreateClusterCommand = class _CreateClusterCommand 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("AmazonEC2ContainerServiceV20141113", "CreateCluster", {}).n("ECSClient", "CreateClusterCommand").f(void 0, void 0).ser(se_CreateClusterCommand).de(de_CreateClusterCommand).build() {
+};
+__name(_CreateClusterCommand, "CreateClusterCommand");
+var CreateClusterCommand = _CreateClusterCommand;
+
+// 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("AmazonEC2ContainerServiceV20141113", "CreateService", {}).n("ECSClient", "CreateServiceCommand").f(void 0, void 0).ser(se_CreateServiceCommand).de(de_CreateServiceCommand).build() {
+};
+__name(_CreateServiceCommand, "CreateServiceCommand");
+var CreateServiceCommand = _CreateServiceCommand;
+
+// src/commands/CreateTaskSetCommand.ts
+
+
+
+var _CreateTaskSetCommand = class _CreateTaskSetCommand 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("AmazonEC2ContainerServiceV20141113", "CreateTaskSet", {}).n("ECSClient", "CreateTaskSetCommand").f(void 0, void 0).ser(se_CreateTaskSetCommand).de(de_CreateTaskSetCommand).build() {
+};
+__name(_CreateTaskSetCommand, "CreateTaskSetCommand");
+var CreateTaskSetCommand = _CreateTaskSetCommand;
+
+// src/commands/DeleteAccountSettingCommand.ts
+
+
+
+var _DeleteAccountSettingCommand = class _DeleteAccountSettingCommand 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("AmazonEC2ContainerServiceV20141113", "DeleteAccountSetting", {}).n("ECSClient", "DeleteAccountSettingCommand").f(void 0, void 0).ser(se_DeleteAccountSettingCommand).de(de_DeleteAccountSettingCommand).build() {
+};
+__name(_DeleteAccountSettingCommand, "DeleteAccountSettingCommand");
+var DeleteAccountSettingCommand = _DeleteAccountSettingCommand;
+
+// src/commands/DeleteAttributesCommand.ts
+
+
+
+var _DeleteAttributesCommand = class _DeleteAttributesCommand 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("AmazonEC2ContainerServiceV20141113", "DeleteAttributes", {}).n("ECSClient", "DeleteAttributesCommand").f(void 0, void 0).ser(se_DeleteAttributesCommand).de(de_DeleteAttributesCommand).build() {
+};
+__name(_DeleteAttributesCommand, "DeleteAttributesCommand");
+var DeleteAttributesCommand = _DeleteAttributesCommand;
+
+// src/commands/DeleteCapacityProviderCommand.ts
+
+
+
+var _DeleteCapacityProviderCommand = class _DeleteCapacityProviderCommand 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("AmazonEC2ContainerServiceV20141113", "DeleteCapacityProvider", {}).n("ECSClient", "DeleteCapacityProviderCommand").f(void 0, void 0).ser(se_DeleteCapacityProviderCommand).de(de_DeleteCapacityProviderCommand).build() {
+};
+__name(_DeleteCapacityProviderCommand, "DeleteCapacityProviderCommand");
+var DeleteCapacityProviderCommand = _DeleteCapacityProviderCommand;
+
+// src/commands/DeleteClusterCommand.ts
+
+
+
+var _DeleteClusterCommand = class _DeleteClusterCommand 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("AmazonEC2ContainerServiceV20141113", "DeleteCluster", {}).n("ECSClient", "DeleteClusterCommand").f(void 0, void 0).ser(se_DeleteClusterCommand).de(de_DeleteClusterCommand).build() {
+};
+__name(_DeleteClusterCommand, "DeleteClusterCommand");
+var DeleteClusterCommand = _DeleteClusterCommand;
+
+// 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("AmazonEC2ContainerServiceV20141113", "DeleteService", {}).n("ECSClient", "DeleteServiceCommand").f(void 0, void 0).ser(se_DeleteServiceCommand).de(de_DeleteServiceCommand).build() {
+};
+__name(_DeleteServiceCommand, "DeleteServiceCommand");
+var DeleteServiceCommand = _DeleteServiceCommand;
+
+// src/commands/DeleteTaskDefinitionsCommand.ts
+
+
+
+var _DeleteTaskDefinitionsCommand = class _DeleteTaskDefinitionsCommand 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("AmazonEC2ContainerServiceV20141113", "DeleteTaskDefinitions", {}).n("ECSClient", "DeleteTaskDefinitionsCommand").f(void 0, void 0).ser(se_DeleteTaskDefinitionsCommand).de(de_DeleteTaskDefinitionsCommand).build() {
+};
+__name(_DeleteTaskDefinitionsCommand, "DeleteTaskDefinitionsCommand");
+var DeleteTaskDefinitionsCommand = _DeleteTaskDefinitionsCommand;
+
+// src/commands/DeleteTaskSetCommand.ts
+
+
+
+var _DeleteTaskSetCommand = class _DeleteTaskSetCommand 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("AmazonEC2ContainerServiceV20141113", "DeleteTaskSet", {}).n("ECSClient", "DeleteTaskSetCommand").f(void 0, void 0).ser(se_DeleteTaskSetCommand).de(de_DeleteTaskSetCommand).build() {
+};
+__name(_DeleteTaskSetCommand, "DeleteTaskSetCommand");
+var DeleteTaskSetCommand = _DeleteTaskSetCommand;
+
+// src/commands/DeregisterContainerInstanceCommand.ts
+
+
+
+var _DeregisterContainerInstanceCommand = class _DeregisterContainerInstanceCommand 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("AmazonEC2ContainerServiceV20141113", "DeregisterContainerInstance", {}).n("ECSClient", "DeregisterContainerInstanceCommand").f(void 0, void 0).ser(se_DeregisterContainerInstanceCommand).de(de_DeregisterContainerInstanceCommand).build() {
+};
+__name(_DeregisterContainerInstanceCommand, "DeregisterContainerInstanceCommand");
+var DeregisterContainerInstanceCommand = _DeregisterContainerInstanceCommand;
+
+// src/commands/DeregisterTaskDefinitionCommand.ts
+
+
+
+var _DeregisterTaskDefinitionCommand = class _DeregisterTaskDefinitionCommand 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("AmazonEC2ContainerServiceV20141113", "DeregisterTaskDefinition", {}).n("ECSClient", "DeregisterTaskDefinitionCommand").f(void 0, void 0).ser(se_DeregisterTaskDefinitionCommand).de(de_DeregisterTaskDefinitionCommand).build() {
+};
+__name(_DeregisterTaskDefinitionCommand, "DeregisterTaskDefinitionCommand");
+var DeregisterTaskDefinitionCommand = _DeregisterTaskDefinitionCommand;
+
+// src/commands/DescribeCapacityProvidersCommand.ts
+
+
+
+var _DescribeCapacityProvidersCommand = class _DescribeCapacityProvidersCommand 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("AmazonEC2ContainerServiceV20141113", "DescribeCapacityProviders", {}).n("ECSClient", "DescribeCapacityProvidersCommand").f(void 0, void 0).ser(se_DescribeCapacityProvidersCommand).de(de_DescribeCapacityProvidersCommand).build() {
+};
+__name(_DescribeCapacityProvidersCommand, "DescribeCapacityProvidersCommand");
+var DescribeCapacityProvidersCommand = _DescribeCapacityProvidersCommand;
+
+// src/commands/DescribeClustersCommand.ts
+
+
+
+var _DescribeClustersCommand = class _DescribeClustersCommand 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("AmazonEC2ContainerServiceV20141113", "DescribeClusters", {}).n("ECSClient", "DescribeClustersCommand").f(void 0, void 0).ser(se_DescribeClustersCommand).de(de_DescribeClustersCommand).build() {
+};
+__name(_DescribeClustersCommand, "DescribeClustersCommand");
+var DescribeClustersCommand = _DescribeClustersCommand;
+
+// src/commands/DescribeContainerInstancesCommand.ts
+
+
+
+var _DescribeContainerInstancesCommand = class _DescribeContainerInstancesCommand 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("AmazonEC2ContainerServiceV20141113", "DescribeContainerInstances", {}).n("ECSClient", "DescribeContainerInstancesCommand").f(void 0, void 0).ser(se_DescribeContainerInstancesCommand).de(de_DescribeContainerInstancesCommand).build() {
+};
+__name(_DescribeContainerInstancesCommand, "DescribeContainerInstancesCommand");
+var DescribeContainerInstancesCommand = _DescribeContainerInstancesCommand;
+
+// src/commands/DescribeServicesCommand.ts
+
+
+
+var _DescribeServicesCommand = class _DescribeServicesCommand 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("AmazonEC2ContainerServiceV20141113", "DescribeServices", {}).n("ECSClient", "DescribeServicesCommand").f(void 0, void 0).ser(se_DescribeServicesCommand).de(de_DescribeServicesCommand).build() {
+};
+__name(_DescribeServicesCommand, "DescribeServicesCommand");
+var DescribeServicesCommand = _DescribeServicesCommand;
+
+// src/commands/DescribeTaskDefinitionCommand.ts
+
+
+
+var _DescribeTaskDefinitionCommand = class _DescribeTaskDefinitionCommand 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("AmazonEC2ContainerServiceV20141113", "DescribeTaskDefinition", {}).n("ECSClient", "DescribeTaskDefinitionCommand").f(void 0, void 0).ser(se_DescribeTaskDefinitionCommand).de(de_DescribeTaskDefinitionCommand).build() {
+};
+__name(_DescribeTaskDefinitionCommand, "DescribeTaskDefinitionCommand");
+var DescribeTaskDefinitionCommand = _DescribeTaskDefinitionCommand;
+
+// src/commands/DescribeTasksCommand.ts
+
+
+
+var _DescribeTasksCommand = class _DescribeTasksCommand 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("AmazonEC2ContainerServiceV20141113", "DescribeTasks", {}).n("ECSClient", "DescribeTasksCommand").f(void 0, void 0).ser(se_DescribeTasksCommand).de(de_DescribeTasksCommand).build() {
+};
+__name(_DescribeTasksCommand, "DescribeTasksCommand");
+var DescribeTasksCommand = _DescribeTasksCommand;
+
+// src/commands/DescribeTaskSetsCommand.ts
+
+
+
+var _DescribeTaskSetsCommand = class _DescribeTaskSetsCommand 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("AmazonEC2ContainerServiceV20141113", "DescribeTaskSets", {}).n("ECSClient", "DescribeTaskSetsCommand").f(void 0, void 0).ser(se_DescribeTaskSetsCommand).de(de_DescribeTaskSetsCommand).build() {
+};
+__name(_DescribeTaskSetsCommand, "DescribeTaskSetsCommand");
+var DescribeTaskSetsCommand = _DescribeTaskSetsCommand;
+
+// src/commands/DiscoverPollEndpointCommand.ts
+
+
+
+var _DiscoverPollEndpointCommand = class _DiscoverPollEndpointCommand 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("AmazonEC2ContainerServiceV20141113", "DiscoverPollEndpoint", {}).n("ECSClient", "DiscoverPollEndpointCommand").f(void 0, void 0).ser(se_DiscoverPollEndpointCommand).de(de_DiscoverPollEndpointCommand).build() {
+};
+__name(_DiscoverPollEndpointCommand, "DiscoverPollEndpointCommand");
+var DiscoverPollEndpointCommand = _DiscoverPollEndpointCommand;
+
+// src/commands/ExecuteCommandCommand.ts
+
+
+
+var _ExecuteCommandCommand = class _ExecuteCommandCommand 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("AmazonEC2ContainerServiceV20141113", "ExecuteCommand", {}).n("ECSClient", "ExecuteCommandCommand").f(void 0, ExecuteCommandResponseFilterSensitiveLog).ser(se_ExecuteCommandCommand).de(de_ExecuteCommandCommand).build() {
+};
+__name(_ExecuteCommandCommand, "ExecuteCommandCommand");
+var ExecuteCommandCommand = _ExecuteCommandCommand;
+
+// src/commands/GetTaskProtectionCommand.ts
+
+
+
+var _GetTaskProtectionCommand = class _GetTaskProtectionCommand 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("AmazonEC2ContainerServiceV20141113", "GetTaskProtection", {}).n("ECSClient", "GetTaskProtectionCommand").f(void 0, void 0).ser(se_GetTaskProtectionCommand).de(de_GetTaskProtectionCommand).build() {
+};
+__name(_GetTaskProtectionCommand, "GetTaskProtectionCommand");
+var GetTaskProtectionCommand = _GetTaskProtectionCommand;
+
+// src/commands/ListAccountSettingsCommand.ts
+
+
+
+var _ListAccountSettingsCommand = class _ListAccountSettingsCommand 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("AmazonEC2ContainerServiceV20141113", "ListAccountSettings", {}).n("ECSClient", "ListAccountSettingsCommand").f(void 0, void 0).ser(se_ListAccountSettingsCommand).de(de_ListAccountSettingsCommand).build() {
+};
+__name(_ListAccountSettingsCommand, "ListAccountSettingsCommand");
+var ListAccountSettingsCommand = _ListAccountSettingsCommand;
+
+// src/commands/ListAttributesCommand.ts
+
+
+
+var _ListAttributesCommand = class _ListAttributesCommand 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("AmazonEC2ContainerServiceV20141113", "ListAttributes", {}).n("ECSClient", "ListAttributesCommand").f(void 0, void 0).ser(se_ListAttributesCommand).de(de_ListAttributesCommand).build() {
+};
+__name(_ListAttributesCommand, "ListAttributesCommand");
+var ListAttributesCommand = _ListAttributesCommand;
+
+// src/commands/ListClustersCommand.ts
+
+
+
+var _ListClustersCommand = class _ListClustersCommand 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("AmazonEC2ContainerServiceV20141113", "ListClusters", {}).n("ECSClient", "ListClustersCommand").f(void 0, void 0).ser(se_ListClustersCommand).de(de_ListClustersCommand).build() {
+};
+__name(_ListClustersCommand, "ListClustersCommand");
+var ListClustersCommand = _ListClustersCommand;
+
+// src/commands/ListContainerInstancesCommand.ts
+
+
+
+var _ListContainerInstancesCommand = class _ListContainerInstancesCommand 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("AmazonEC2ContainerServiceV20141113", "ListContainerInstances", {}).n("ECSClient", "ListContainerInstancesCommand").f(void 0, void 0).ser(se_ListContainerInstancesCommand).de(de_ListContainerInstancesCommand).build() {
+};
+__name(_ListContainerInstancesCommand, "ListContainerInstancesCommand");
+var ListContainerInstancesCommand = _ListContainerInstancesCommand;
+
+// src/commands/ListServicesByNamespaceCommand.ts
+
+
+
+var _ListServicesByNamespaceCommand = class _ListServicesByNamespaceCommand 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("AmazonEC2ContainerServiceV20141113", "ListServicesByNamespace", {}).n("ECSClient", "ListServicesByNamespaceCommand").f(void 0, void 0).ser(se_ListServicesByNamespaceCommand).de(de_ListServicesByNamespaceCommand).build() {
+};
+__name(_ListServicesByNamespaceCommand, "ListServicesByNamespaceCommand");
+var ListServicesByNamespaceCommand = _ListServicesByNamespaceCommand;
+
+// 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("AmazonEC2ContainerServiceV20141113", "ListServices", {}).n("ECSClient", "ListServicesCommand").f(void 0, void 0).ser(se_ListServicesCommand).de(de_ListServicesCommand).build() {
+};
+__name(_ListServicesCommand, "ListServicesCommand");
+var ListServicesCommand = _ListServicesCommand;
+
+// 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("AmazonEC2ContainerServiceV20141113", "ListTagsForResource", {}).n("ECSClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ListTaskDefinitionFamiliesCommand.ts
+
+
+
+var _ListTaskDefinitionFamiliesCommand = class _ListTaskDefinitionFamiliesCommand 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("AmazonEC2ContainerServiceV20141113", "ListTaskDefinitionFamilies", {}).n("ECSClient", "ListTaskDefinitionFamiliesCommand").f(void 0, void 0).ser(se_ListTaskDefinitionFamiliesCommand).de(de_ListTaskDefinitionFamiliesCommand).build() {
+};
+__name(_ListTaskDefinitionFamiliesCommand, "ListTaskDefinitionFamiliesCommand");
+var ListTaskDefinitionFamiliesCommand = _ListTaskDefinitionFamiliesCommand;
+
+// src/commands/ListTaskDefinitionsCommand.ts
+
+
+
+var _ListTaskDefinitionsCommand = class _ListTaskDefinitionsCommand 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("AmazonEC2ContainerServiceV20141113", "ListTaskDefinitions", {}).n("ECSClient", "ListTaskDefinitionsCommand").f(void 0, void 0).ser(se_ListTaskDefinitionsCommand).de(de_ListTaskDefinitionsCommand).build() {
+};
+__name(_ListTaskDefinitionsCommand, "ListTaskDefinitionsCommand");
+var ListTaskDefinitionsCommand = _ListTaskDefinitionsCommand;
+
+// src/commands/ListTasksCommand.ts
+
+
+
+var _ListTasksCommand = class _ListTasksCommand 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("AmazonEC2ContainerServiceV20141113", "ListTasks", {}).n("ECSClient", "ListTasksCommand").f(void 0, void 0).ser(se_ListTasksCommand).de(de_ListTasksCommand).build() {
+};
+__name(_ListTasksCommand, "ListTasksCommand");
+var ListTasksCommand = _ListTasksCommand;
+
+// src/commands/PutAccountSettingCommand.ts
+
+
+
+var _PutAccountSettingCommand = class _PutAccountSettingCommand 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("AmazonEC2ContainerServiceV20141113", "PutAccountSetting", {}).n("ECSClient", "PutAccountSettingCommand").f(void 0, void 0).ser(se_PutAccountSettingCommand).de(de_PutAccountSettingCommand).build() {
+};
+__name(_PutAccountSettingCommand, "PutAccountSettingCommand");
+var PutAccountSettingCommand = _PutAccountSettingCommand;
+
+// src/commands/PutAccountSettingDefaultCommand.ts
+
+
+
+var _PutAccountSettingDefaultCommand = class _PutAccountSettingDefaultCommand 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("AmazonEC2ContainerServiceV20141113", "PutAccountSettingDefault", {}).n("ECSClient", "PutAccountSettingDefaultCommand").f(void 0, void 0).ser(se_PutAccountSettingDefaultCommand).de(de_PutAccountSettingDefaultCommand).build() {
+};
+__name(_PutAccountSettingDefaultCommand, "PutAccountSettingDefaultCommand");
+var PutAccountSettingDefaultCommand = _PutAccountSettingDefaultCommand;
+
+// src/commands/PutAttributesCommand.ts
+
+
+
+var _PutAttributesCommand = class _PutAttributesCommand 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("AmazonEC2ContainerServiceV20141113", "PutAttributes", {}).n("ECSClient", "PutAttributesCommand").f(void 0, void 0).ser(se_PutAttributesCommand).de(de_PutAttributesCommand).build() {
+};
+__name(_PutAttributesCommand, "PutAttributesCommand");
+var PutAttributesCommand = _PutAttributesCommand;
+
+// src/commands/PutClusterCapacityProvidersCommand.ts
+
+
+
+var _PutClusterCapacityProvidersCommand = class _PutClusterCapacityProvidersCommand 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("AmazonEC2ContainerServiceV20141113", "PutClusterCapacityProviders", {}).n("ECSClient", "PutClusterCapacityProvidersCommand").f(void 0, void 0).ser(se_PutClusterCapacityProvidersCommand).de(de_PutClusterCapacityProvidersCommand).build() {
+};
+__name(_PutClusterCapacityProvidersCommand, "PutClusterCapacityProvidersCommand");
+var PutClusterCapacityProvidersCommand = _PutClusterCapacityProvidersCommand;
+
+// src/commands/RegisterContainerInstanceCommand.ts
+
+
+
+var _RegisterContainerInstanceCommand = class _RegisterContainerInstanceCommand 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("AmazonEC2ContainerServiceV20141113", "RegisterContainerInstance", {}).n("ECSClient", "RegisterContainerInstanceCommand").f(void 0, void 0).ser(se_RegisterContainerInstanceCommand).de(de_RegisterContainerInstanceCommand).build() {
+};
+__name(_RegisterContainerInstanceCommand, "RegisterContainerInstanceCommand");
+var RegisterContainerInstanceCommand = _RegisterContainerInstanceCommand;
+
+// src/commands/RegisterTaskDefinitionCommand.ts
+
+
+
+var _RegisterTaskDefinitionCommand = class _RegisterTaskDefinitionCommand 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("AmazonEC2ContainerServiceV20141113", "RegisterTaskDefinition", {}).n("ECSClient", "RegisterTaskDefinitionCommand").f(void 0, void 0).ser(se_RegisterTaskDefinitionCommand).de(de_RegisterTaskDefinitionCommand).build() {
+};
+__name(_RegisterTaskDefinitionCommand, "RegisterTaskDefinitionCommand");
+var RegisterTaskDefinitionCommand = _RegisterTaskDefinitionCommand;
+
+// src/commands/RunTaskCommand.ts
+
+
+
+var _RunTaskCommand = class _RunTaskCommand 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("AmazonEC2ContainerServiceV20141113", "RunTask", {}).n("ECSClient", "RunTaskCommand").f(void 0, void 0).ser(se_RunTaskCommand).de(de_RunTaskCommand).build() {
+};
+__name(_RunTaskCommand, "RunTaskCommand");
+var RunTaskCommand = _RunTaskCommand;
+
+// src/commands/StartTaskCommand.ts
+
+
+
+var _StartTaskCommand = class _StartTaskCommand 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("AmazonEC2ContainerServiceV20141113", "StartTask", {}).n("ECSClient", "StartTaskCommand").f(void 0, void 0).ser(se_StartTaskCommand).de(de_StartTaskCommand).build() {
+};
+__name(_StartTaskCommand, "StartTaskCommand");
+var StartTaskCommand = _StartTaskCommand;
+
+// src/commands/StopTaskCommand.ts
+
+
+
+var _StopTaskCommand = class _StopTaskCommand 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("AmazonEC2ContainerServiceV20141113", "StopTask", {}).n("ECSClient", "StopTaskCommand").f(void 0, void 0).ser(se_StopTaskCommand).de(de_StopTaskCommand).build() {
+};
+__name(_StopTaskCommand, "StopTaskCommand");
+var StopTaskCommand = _StopTaskCommand;
+
+// src/commands/SubmitAttachmentStateChangesCommand.ts
+
+
+
+var _SubmitAttachmentStateChangesCommand = class _SubmitAttachmentStateChangesCommand 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("AmazonEC2ContainerServiceV20141113", "SubmitAttachmentStateChanges", {}).n("ECSClient", "SubmitAttachmentStateChangesCommand").f(void 0, void 0).ser(se_SubmitAttachmentStateChangesCommand).de(de_SubmitAttachmentStateChangesCommand).build() {
+};
+__name(_SubmitAttachmentStateChangesCommand, "SubmitAttachmentStateChangesCommand");
+var SubmitAttachmentStateChangesCommand = _SubmitAttachmentStateChangesCommand;
+
+// src/commands/SubmitContainerStateChangeCommand.ts
+
+
+
+var _SubmitContainerStateChangeCommand = class _SubmitContainerStateChangeCommand 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("AmazonEC2ContainerServiceV20141113", "SubmitContainerStateChange", {}).n("ECSClient", "SubmitContainerStateChangeCommand").f(void 0, void 0).ser(se_SubmitContainerStateChangeCommand).de(de_SubmitContainerStateChangeCommand).build() {
+};
+__name(_SubmitContainerStateChangeCommand, "SubmitContainerStateChangeCommand");
+var SubmitContainerStateChangeCommand = _SubmitContainerStateChangeCommand;
+
+// src/commands/SubmitTaskStateChangeCommand.ts
+
+
+
+var _SubmitTaskStateChangeCommand = class _SubmitTaskStateChangeCommand 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("AmazonEC2ContainerServiceV20141113", "SubmitTaskStateChange", {}).n("ECSClient", "SubmitTaskStateChangeCommand").f(void 0, void 0).ser(se_SubmitTaskStateChangeCommand).de(de_SubmitTaskStateChangeCommand).build() {
+};
+__name(_SubmitTaskStateChangeCommand, "SubmitTaskStateChangeCommand");
+var SubmitTaskStateChangeCommand = _SubmitTaskStateChangeCommand;
+
+// 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("AmazonEC2ContainerServiceV20141113", "TagResource", {}).n("ECSClient", "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("AmazonEC2ContainerServiceV20141113", "UntagResource", {}).n("ECSClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateCapacityProviderCommand.ts
+
+
+
+var _UpdateCapacityProviderCommand = class _UpdateCapacityProviderCommand 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("AmazonEC2ContainerServiceV20141113", "UpdateCapacityProvider", {}).n("ECSClient", "UpdateCapacityProviderCommand").f(void 0, void 0).ser(se_UpdateCapacityProviderCommand).de(de_UpdateCapacityProviderCommand).build() {
+};
+__name(_UpdateCapacityProviderCommand, "UpdateCapacityProviderCommand");
+var UpdateCapacityProviderCommand = _UpdateCapacityProviderCommand;
+
+// src/commands/UpdateClusterCommand.ts
+
+
+
+var _UpdateClusterCommand = class _UpdateClusterCommand 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("AmazonEC2ContainerServiceV20141113", "UpdateCluster", {}).n("ECSClient", "UpdateClusterCommand").f(void 0, void 0).ser(se_UpdateClusterCommand).de(de_UpdateClusterCommand).build() {
+};
+__name(_UpdateClusterCommand, "UpdateClusterCommand");
+var UpdateClusterCommand = _UpdateClusterCommand;
+
+// src/commands/UpdateClusterSettingsCommand.ts
+
+
+
+var _UpdateClusterSettingsCommand = class _UpdateClusterSettingsCommand 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("AmazonEC2ContainerServiceV20141113", "UpdateClusterSettings", {}).n("ECSClient", "UpdateClusterSettingsCommand").f(void 0, void 0).ser(se_UpdateClusterSettingsCommand).de(de_UpdateClusterSettingsCommand).build() {
+};
+__name(_UpdateClusterSettingsCommand, "UpdateClusterSettingsCommand");
+var UpdateClusterSettingsCommand = _UpdateClusterSettingsCommand;
+
+// src/commands/UpdateContainerAgentCommand.ts
+
+
+
+var _UpdateContainerAgentCommand = class _UpdateContainerAgentCommand 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("AmazonEC2ContainerServiceV20141113", "UpdateContainerAgent", {}).n("ECSClient", "UpdateContainerAgentCommand").f(void 0, void 0).ser(se_UpdateContainerAgentCommand).de(de_UpdateContainerAgentCommand).build() {
+};
+__name(_UpdateContainerAgentCommand, "UpdateContainerAgentCommand");
+var UpdateContainerAgentCommand = _UpdateContainerAgentCommand;
+
+// src/commands/UpdateContainerInstancesStateCommand.ts
+
+
+
+var _UpdateContainerInstancesStateCommand = class _UpdateContainerInstancesStateCommand 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("AmazonEC2ContainerServiceV20141113", "UpdateContainerInstancesState", {}).n("ECSClient", "UpdateContainerInstancesStateCommand").f(void 0, void 0).ser(se_UpdateContainerInstancesStateCommand).de(de_UpdateContainerInstancesStateCommand).build() {
+};
+__name(_UpdateContainerInstancesStateCommand, "UpdateContainerInstancesStateCommand");
+var UpdateContainerInstancesStateCommand = _UpdateContainerInstancesStateCommand;
+
+// 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("AmazonEC2ContainerServiceV20141113", "UpdateService", {}).n("ECSClient", "UpdateServiceCommand").f(void 0, void 0).ser(se_UpdateServiceCommand).de(de_UpdateServiceCommand).build() {
+};
+__name(_UpdateServiceCommand, "UpdateServiceCommand");
+var UpdateServiceCommand = _UpdateServiceCommand;
+
+// src/commands/UpdateServicePrimaryTaskSetCommand.ts
+
+
+
+var _UpdateServicePrimaryTaskSetCommand = class _UpdateServicePrimaryTaskSetCommand 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("AmazonEC2ContainerServiceV20141113", "UpdateServicePrimaryTaskSet", {}).n("ECSClient", "UpdateServicePrimaryTaskSetCommand").f(void 0, void 0).ser(se_UpdateServicePrimaryTaskSetCommand).de(de_UpdateServicePrimaryTaskSetCommand).build() {
+};
+__name(_UpdateServicePrimaryTaskSetCommand, "UpdateServicePrimaryTaskSetCommand");
+var UpdateServicePrimaryTaskSetCommand = _UpdateServicePrimaryTaskSetCommand;
+
+// src/commands/UpdateTaskProtectionCommand.ts
+
+
+
+var _UpdateTaskProtectionCommand = class _UpdateTaskProtectionCommand 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("AmazonEC2ContainerServiceV20141113", "UpdateTaskProtection", {}).n("ECSClient", "UpdateTaskProtectionCommand").f(void 0, void 0).ser(se_UpdateTaskProtectionCommand).de(de_UpdateTaskProtectionCommand).build() {
+};
+__name(_UpdateTaskProtectionCommand, "UpdateTaskProtectionCommand");
+var UpdateTaskProtectionCommand = _UpdateTaskProtectionCommand;
+
+// src/commands/UpdateTaskSetCommand.ts
+
+
+
+var _UpdateTaskSetCommand = class _UpdateTaskSetCommand 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("AmazonEC2ContainerServiceV20141113", "UpdateTaskSet", {}).n("ECSClient", "UpdateTaskSetCommand").f(void 0, void 0).ser(se_UpdateTaskSetCommand).de(de_UpdateTaskSetCommand).build() {
+};
+__name(_UpdateTaskSetCommand, "UpdateTaskSetCommand");
+var UpdateTaskSetCommand = _UpdateTaskSetCommand;
+
+// src/ECS.ts
+var commands = {
+  CreateCapacityProviderCommand,
+  CreateClusterCommand,
+  CreateServiceCommand,
+  CreateTaskSetCommand,
+  DeleteAccountSettingCommand,
+  DeleteAttributesCommand,
+  DeleteCapacityProviderCommand,
+  DeleteClusterCommand,
+  DeleteServiceCommand,
+  DeleteTaskDefinitionsCommand,
+  DeleteTaskSetCommand,
+  DeregisterContainerInstanceCommand,
+  DeregisterTaskDefinitionCommand,
+  DescribeCapacityProvidersCommand,
+  DescribeClustersCommand,
+  DescribeContainerInstancesCommand,
+  DescribeServicesCommand,
+  DescribeTaskDefinitionCommand,
+  DescribeTasksCommand,
+  DescribeTaskSetsCommand,
+  DiscoverPollEndpointCommand,
+  ExecuteCommandCommand,
+  GetTaskProtectionCommand,
+  ListAccountSettingsCommand,
+  ListAttributesCommand,
+  ListClustersCommand,
+  ListContainerInstancesCommand,
+  ListServicesCommand,
+  ListServicesByNamespaceCommand,
+  ListTagsForResourceCommand,
+  ListTaskDefinitionFamiliesCommand,
+  ListTaskDefinitionsCommand,
+  ListTasksCommand,
+  PutAccountSettingCommand,
+  PutAccountSettingDefaultCommand,
+  PutAttributesCommand,
+  PutClusterCapacityProvidersCommand,
+  RegisterContainerInstanceCommand,
+  RegisterTaskDefinitionCommand,
+  RunTaskCommand,
+  StartTaskCommand,
+  StopTaskCommand,
+  SubmitAttachmentStateChangesCommand,
+  SubmitContainerStateChangeCommand,
+  SubmitTaskStateChangeCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateCapacityProviderCommand,
+  UpdateClusterCommand,
+  UpdateClusterSettingsCommand,
+  UpdateContainerAgentCommand,
+  UpdateContainerInstancesStateCommand,
+  UpdateServiceCommand,
+  UpdateServicePrimaryTaskSetCommand,
+  UpdateTaskProtectionCommand,
+  UpdateTaskSetCommand
+};
+var _ECS = class _ECS extends ECSClient {
+};
+__name(_ECS, "ECS");
+var ECS = _ECS;
+(0, import_smithy_client.createAggregatedClient)(commands, ECS);
+
+// src/pagination/ListAccountSettingsPaginator.ts
+
+var paginateListAccountSettings = (0, import_core.createPaginator)(ECSClient, ListAccountSettingsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListAttributesPaginator.ts
+
+var paginateListAttributes = (0, import_core.createPaginator)(ECSClient, ListAttributesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListClustersPaginator.ts
+
+var paginateListClusters = (0, import_core.createPaginator)(ECSClient, ListClustersCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListContainerInstancesPaginator.ts
+
+var paginateListContainerInstances = (0, import_core.createPaginator)(ECSClient, ListContainerInstancesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListServicesByNamespacePaginator.ts
+
+var paginateListServicesByNamespace = (0, import_core.createPaginator)(ECSClient, ListServicesByNamespaceCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListServicesPaginator.ts
+
+var paginateListServices = (0, import_core.createPaginator)(ECSClient, ListServicesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListTaskDefinitionFamiliesPaginator.ts
+
+var paginateListTaskDefinitionFamilies = (0, import_core.createPaginator)(ECSClient, ListTaskDefinitionFamiliesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListTaskDefinitionsPaginator.ts
+
+var paginateListTaskDefinitions = (0, import_core.createPaginator)(ECSClient, ListTaskDefinitionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListTasksPaginator.ts
+
+var paginateListTasks = (0, import_core.createPaginator)(ECSClient, ListTasksCommand, "nextToken", "nextToken", "maxResults");
+
+// src/waiters/waitForServicesInactive.ts
+var import_util_waiter = require("@smithy/util-waiter");
+var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeServicesCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.failures);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.reason;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "MISSING") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.services);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "INACTIVE") {
+          return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+        }
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForServicesInactive = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForServicesInactive");
+var waitUntilServicesInactive = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilServicesInactive");
+
+// src/waiters/waitForServicesStable.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeServicesCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.failures);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.reason;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "MISSING") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.services);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "DRAINING") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.services);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "INACTIVE") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const filterRes_2 = result.services.filter((element_1) => {
+          return !(element_1.deployments.length == 1 && element_1.runningCount == element_1.desiredCount);
+        });
+        return filterRes_2.length == 0;
+      }, "returnComparator");
+      if (returnComparator() == true) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForServicesStable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "waitForServicesStable");
+var waitUntilServicesStable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilServicesStable");
+
+// src/waiters/waitForTasksRunning.ts
+
+var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeTasksCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.tasks);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.lastStatus;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "STOPPED") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.failures);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.reason;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "MISSING") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.tasks);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.lastStatus;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "RUNNING";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForTasksRunning = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 6, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+}, "waitForTasksRunning");
+var waitUntilTasksRunning = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 6, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilTasksRunning");
+
+// src/waiters/waitForTasksStopped.ts
+
+var checkState4 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeTasksCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.tasks);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.lastStatus;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "STOPPED";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForTasksStopped = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 6, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
+}, "waitForTasksStopped");
+var waitUntilTasksStopped = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 6, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilTasksStopped");
+// Annotate the CommonJS export names for ESM import in node:
+
+0 && (module.exports = {
+  ECSServiceException,
+  __Client,
+  ECSClient,
+  ECS,
+  $Command,
+  CreateCapacityProviderCommand,
+  CreateClusterCommand,
+  CreateServiceCommand,
+  CreateTaskSetCommand,
+  DeleteAccountSettingCommand,
+  DeleteAttributesCommand,
+  DeleteCapacityProviderCommand,
+  DeleteClusterCommand,
+  DeleteServiceCommand,
+  DeleteTaskDefinitionsCommand,
+  DeleteTaskSetCommand,
+  DeregisterContainerInstanceCommand,
+  DeregisterTaskDefinitionCommand,
+  DescribeCapacityProvidersCommand,
+  DescribeClustersCommand,
+  DescribeContainerInstancesCommand,
+  DescribeServicesCommand,
+  DescribeTaskDefinitionCommand,
+  DescribeTaskSetsCommand,
+  DescribeTasksCommand,
+  DiscoverPollEndpointCommand,
+  ExecuteCommandCommand,
+  GetTaskProtectionCommand,
+  ListAccountSettingsCommand,
+  ListAttributesCommand,
+  ListClustersCommand,
+  ListContainerInstancesCommand,
+  ListServicesByNamespaceCommand,
+  ListServicesCommand,
+  ListTagsForResourceCommand,
+  ListTaskDefinitionFamiliesCommand,
+  ListTaskDefinitionsCommand,
+  ListTasksCommand,
+  PutAccountSettingCommand,
+  PutAccountSettingDefaultCommand,
+  PutAttributesCommand,
+  PutClusterCapacityProvidersCommand,
+  RegisterContainerInstanceCommand,
+  RegisterTaskDefinitionCommand,
+  RunTaskCommand,
+  StartTaskCommand,
+  StopTaskCommand,
+  SubmitAttachmentStateChangesCommand,
+  SubmitContainerStateChangeCommand,
+  SubmitTaskStateChangeCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateCapacityProviderCommand,
+  UpdateClusterCommand,
+  UpdateClusterSettingsCommand,
+  UpdateContainerAgentCommand,
+  UpdateContainerInstancesStateCommand,
+  UpdateServiceCommand,
+  UpdateServicePrimaryTaskSetCommand,
+  UpdateTaskProtectionCommand,
+  UpdateTaskSetCommand,
+  paginateListAccountSettings,
+  paginateListAttributes,
+  paginateListClusters,
+  paginateListContainerInstances,
+  paginateListServicesByNamespace,
+  paginateListServices,
+  paginateListTaskDefinitionFamilies,
+  paginateListTaskDefinitions,
+  paginateListTasks,
+  waitForServicesInactive,
+  waitUntilServicesInactive,
+  waitForServicesStable,
+  waitUntilServicesStable,
+  waitForTasksRunning,
+  waitUntilTasksRunning,
+  waitForTasksStopped,
+  waitUntilTasksStopped,
+  AccessDeniedException,
+  AgentUpdateStatus,
+  ClientException,
+  ManagedDraining,
+  ManagedScalingStatus,
+  ManagedTerminationProtection,
+  CapacityProviderStatus,
+  CapacityProviderUpdateStatus,
+  InvalidParameterException,
+  LimitExceededException,
+  ServerException,
+  UpdateInProgressException,
+  ExecuteCommandLogging,
+  ClusterSettingName,
+  NamespaceNotFoundException,
+  ClusterNotFoundException,
+  DeploymentControllerType,
+  LaunchType,
+  AssignPublicIp,
+  PlacementConstraintType,
+  PlacementStrategyType,
+  PropagateTags,
+  SchedulingStrategy,
+  LogDriver,
+  TaskFilesystemType,
+  EBSResourceType,
+  DeploymentRolloutState,
+  ScaleUnit,
+  StabilityStatus,
+  PlatformTaskDefinitionIncompatibilityException,
+  PlatformUnknownException,
+  UnsupportedFeatureException,
+  ServiceNotActiveException,
+  ServiceNotFoundException,
+  SettingName,
+  SettingType,
+  TargetType,
+  TargetNotFoundException,
+  ClusterContainsContainerInstancesException,
+  ClusterContainsServicesException,
+  ClusterContainsTasksException,
+  Compatibility,
+  ContainerCondition,
+  EnvironmentFileType,
+  FirelensConfigurationType,
+  DeviceCgroupPermission,
+  ApplicationProtocol,
+  TransportProtocol,
+  ResourceType,
+  UlimitName,
+  IpcMode,
+  NetworkMode,
+  PidMode,
+  TaskDefinitionPlacementConstraintType,
+  ProxyConfigurationType,
+  CPUArchitecture,
+  OSFamily,
+  TaskDefinitionStatus,
+  Scope,
+  EFSAuthorizationConfigIAM,
+  EFSTransitEncryption,
+  TaskSetNotFoundException,
+  InstanceHealthCheckState,
+  InstanceHealthCheckType,
+  CapacityProviderField,
+  ClusterField,
+  ContainerInstanceField,
+  ServiceField,
+  TaskDefinitionField,
+  TaskField,
+  Connectivity,
+  HealthStatus,
+  ManagedAgentName,
+  TaskStopCode,
+  TaskSetField,
+  TargetNotConnectedException,
+  ResourceNotFoundException,
+  ContainerInstanceStatus,
+  TaskDefinitionFamilyStatus,
+  SortOrder,
+  DesiredStatus,
+  AttributeLimitExceededException,
+  ResourceInUseException,
+  PlatformDeviceType,
+  BlockedException,
+  ConflictException,
+  MissingVersionException,
+  NoUpdateAvailableException,
+  SessionFilterSensitiveLog,
+  ExecuteCommandResponseFilterSensitiveLog
+});
+