File Explorer

1'use strict';2 3var client$1 = require('@aws-sdk/core/client');4var core = require('@smithy/core');5var client = require('@smithy/core/client');6var config = require('@smithy/core/config');7var endpoints = require('@smithy/core/endpoints');8var protocols = require('@smithy/core/protocols');9var retry = require('@smithy/core/retry');10var schema = require('@smithy/core/schema');11var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');12var runtimeConfig = require('./runtimeConfig');13var schemas_0 = require('./schemas/schemas_0');14var errors = require('./models/errors');15var ECSServiceException = require('./models/ECSServiceException');16 17const resolveClientEndpointParameters = (options) => {18    return Object.assign(options, {19        useDualstackEndpoint: options.useDualstackEndpoint ?? false,20        useFipsEndpoint: options.useFipsEndpoint ?? false,21        defaultSigningName: "ecs",22    });23};24const commonParams = {25    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },26    Endpoint: { type: "builtInParams", name: "endpoint" },27    Region: { type: "builtInParams", name: "region" },28    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },29};30 31const getHttpAuthExtensionConfiguration = (runtimeConfig) => {32    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;33    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;34    let _credentials = runtimeConfig.credentials;35    return {36        setHttpAuthScheme(httpAuthScheme) {37            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);38            if (index === -1) {39                _httpAuthSchemes.push(httpAuthScheme);40            }41            else {42                _httpAuthSchemes.splice(index, 1, httpAuthScheme);43            }44        },45        httpAuthSchemes() {46            return _httpAuthSchemes;47        },48        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {49            _httpAuthSchemeProvider = httpAuthSchemeProvider;50        },51        httpAuthSchemeProvider() {52            return _httpAuthSchemeProvider;53        },54        setCredentials(credentials) {55            _credentials = credentials;56        },57        credentials() {58            return _credentials;59        },60    };61};62const resolveHttpAuthRuntimeConfig = (config) => {63    return {64        httpAuthSchemes: config.httpAuthSchemes(),65        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),66        credentials: config.credentials(),67    };68};69 70const resolveRuntimeExtensions = (runtimeConfig, extensions) => {71    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));72    extensions.forEach((extension) => extension.configure(extensionConfiguration));73    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));74};75 76class ECSClient extends client.Client {77    config;78    constructor(...[configuration]) {79        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});80        super(_config_0);81        this.initConfig = _config_0;82        const _config_1 = resolveClientEndpointParameters(_config_0);83        const _config_2 = client$1.resolveUserAgentConfig(_config_1);84        const _config_3 = retry.resolveRetryConfig(_config_2);85        const _config_4 = config.resolveRegionConfig(_config_3);86        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);87        const _config_6 = endpoints.resolveEndpointConfig(_config_5);88        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);89        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);90        this.config = _config_8;91        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));92        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));93        this.middlewareStack.use(retry.getRetryPlugin(this.config));94        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));95        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));96        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));97        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));98        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {99            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultECSHttpAuthSchemeParametersProvider,100            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({101                "aws.auth#sigv4": config.credentials,102            }),103        }));104        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));105    }106    destroy() {107        super.destroy();108    }109}110 111class ContinueServiceDeploymentCommand extends client.Command112    .classBuilder()113    .ep(commonParams)114    .m(function (Command, cs, config, o) {115    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];116})117    .s("AmazonEC2ContainerServiceV20141113", "ContinueServiceDeployment", {})118    .n("ECSClient", "ContinueServiceDeploymentCommand")119    .sc(schemas_0.ContinueServiceDeployment$)120    .build() {121}122 123class CreateCapacityProviderCommand extends client.Command124    .classBuilder()125    .ep(commonParams)126    .m(function (Command, cs, config, o) {127    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];128})129    .s("AmazonEC2ContainerServiceV20141113", "CreateCapacityProvider", {})130    .n("ECSClient", "CreateCapacityProviderCommand")131    .sc(schemas_0.CreateCapacityProvider$)132    .build() {133}134 135class CreateClusterCommand extends client.Command136    .classBuilder()137    .ep(commonParams)138    .m(function (Command, cs, config, o) {139    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];140})141    .s("AmazonEC2ContainerServiceV20141113", "CreateCluster", {})142    .n("ECSClient", "CreateClusterCommand")143    .sc(schemas_0.CreateCluster$)144    .build() {145}146 147class CreateDaemonCommand extends client.Command148    .classBuilder()149    .ep(commonParams)150    .m(function (Command, cs, config, o) {151    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];152})153    .s("AmazonEC2ContainerServiceV20141113", "CreateDaemon", {})154    .n("ECSClient", "CreateDaemonCommand")155    .sc(schemas_0.CreateDaemon$)156    .build() {157}158 159class CreateExpressGatewayServiceCommand extends client.Command160    .classBuilder()161    .ep(commonParams)162    .m(function (Command, cs, config, o) {163    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];164})165    .s("AmazonEC2ContainerServiceV20141113", "CreateExpressGatewayService", {})166    .n("ECSClient", "CreateExpressGatewayServiceCommand")167    .sc(schemas_0.CreateExpressGatewayService$)168    .build() {169}170 171class CreateServiceCommand extends client.Command172    .classBuilder()173    .ep(commonParams)174    .m(function (Command, cs, config, o) {175    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];176})177    .s("AmazonEC2ContainerServiceV20141113", "CreateService", {})178    .n("ECSClient", "CreateServiceCommand")179    .sc(schemas_0.CreateService$)180    .build() {181}182 183class CreateTaskSetCommand extends client.Command184    .classBuilder()185    .ep(commonParams)186    .m(function (Command, cs, config, o) {187    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];188})189    .s("AmazonEC2ContainerServiceV20141113", "CreateTaskSet", {})190    .n("ECSClient", "CreateTaskSetCommand")191    .sc(schemas_0.CreateTaskSet$)192    .build() {193}194 195class DeleteAccountSettingCommand extends client.Command196    .classBuilder()197    .ep(commonParams)198    .m(function (Command, cs, config, o) {199    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];200})201    .s("AmazonEC2ContainerServiceV20141113", "DeleteAccountSetting", {})202    .n("ECSClient", "DeleteAccountSettingCommand")203    .sc(schemas_0.DeleteAccountSetting$)204    .build() {205}206 207class DeleteAttributesCommand extends client.Command208    .classBuilder()209    .ep(commonParams)210    .m(function (Command, cs, config, o) {211    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];212})213    .s("AmazonEC2ContainerServiceV20141113", "DeleteAttributes", {})214    .n("ECSClient", "DeleteAttributesCommand")215    .sc(schemas_0.DeleteAttributes$)216    .build() {217}218 219class DeleteCapacityProviderCommand extends client.Command220    .classBuilder()221    .ep(commonParams)222    .m(function (Command, cs, config, o) {223    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];224})225    .s("AmazonEC2ContainerServiceV20141113", "DeleteCapacityProvider", {})226    .n("ECSClient", "DeleteCapacityProviderCommand")227    .sc(schemas_0.DeleteCapacityProvider$)228    .build() {229}230 231class DeleteClusterCommand extends client.Command232    .classBuilder()233    .ep(commonParams)234    .m(function (Command, cs, config, o) {235    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];236})237    .s("AmazonEC2ContainerServiceV20141113", "DeleteCluster", {})238    .n("ECSClient", "DeleteClusterCommand")239    .sc(schemas_0.DeleteCluster$)240    .build() {241}242 243class DeleteDaemonCommand extends client.Command244    .classBuilder()245    .ep(commonParams)246    .m(function (Command, cs, config, o) {247    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];248})249    .s("AmazonEC2ContainerServiceV20141113", "DeleteDaemon", {})250    .n("ECSClient", "DeleteDaemonCommand")251    .sc(schemas_0.DeleteDaemon$)252    .build() {253}254 255class DeleteDaemonTaskDefinitionCommand extends client.Command256    .classBuilder()257    .ep(commonParams)258    .m(function (Command, cs, config, o) {259    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];260})261    .s("AmazonEC2ContainerServiceV20141113", "DeleteDaemonTaskDefinition", {})262    .n("ECSClient", "DeleteDaemonTaskDefinitionCommand")263    .sc(schemas_0.DeleteDaemonTaskDefinition$)264    .build() {265}266 267class DeleteExpressGatewayServiceCommand extends client.Command268    .classBuilder()269    .ep(commonParams)270    .m(function (Command, cs, config, o) {271    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];272})273    .s("AmazonEC2ContainerServiceV20141113", "DeleteExpressGatewayService", {})274    .n("ECSClient", "DeleteExpressGatewayServiceCommand")275    .sc(schemas_0.DeleteExpressGatewayService$)276    .build() {277}278 279class DeleteServiceCommand extends client.Command280    .classBuilder()281    .ep(commonParams)282    .m(function (Command, cs, config, o) {283    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];284})285    .s("AmazonEC2ContainerServiceV20141113", "DeleteService", {})286    .n("ECSClient", "DeleteServiceCommand")287    .sc(schemas_0.DeleteService$)288    .build() {289}290 291class DeleteTaskDefinitionsCommand extends client.Command292    .classBuilder()293    .ep(commonParams)294    .m(function (Command, cs, config, o) {295    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];296})297    .s("AmazonEC2ContainerServiceV20141113", "DeleteTaskDefinitions", {})298    .n("ECSClient", "DeleteTaskDefinitionsCommand")299    .sc(schemas_0.DeleteTaskDefinitions$)300    .build() {301}302 303class DeleteTaskSetCommand extends client.Command304    .classBuilder()305    .ep(commonParams)306    .m(function (Command, cs, config, o) {307    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];308})309    .s("AmazonEC2ContainerServiceV20141113", "DeleteTaskSet", {})310    .n("ECSClient", "DeleteTaskSetCommand")311    .sc(schemas_0.DeleteTaskSet$)312    .build() {313}314 315class DeregisterContainerInstanceCommand extends client.Command316    .classBuilder()317    .ep(commonParams)318    .m(function (Command, cs, config, o) {319    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];320})321    .s("AmazonEC2ContainerServiceV20141113", "DeregisterContainerInstance", {})322    .n("ECSClient", "DeregisterContainerInstanceCommand")323    .sc(schemas_0.DeregisterContainerInstance$)324    .build() {325}326 327class DeregisterTaskDefinitionCommand extends client.Command328    .classBuilder()329    .ep(commonParams)330    .m(function (Command, cs, config, o) {331    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];332})333    .s("AmazonEC2ContainerServiceV20141113", "DeregisterTaskDefinition", {})334    .n("ECSClient", "DeregisterTaskDefinitionCommand")335    .sc(schemas_0.DeregisterTaskDefinition$)336    .build() {337}338 339class DescribeCapacityProvidersCommand extends client.Command340    .classBuilder()341    .ep(commonParams)342    .m(function (Command, cs, config, o) {343    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];344})345    .s("AmazonEC2ContainerServiceV20141113", "DescribeCapacityProviders", {})346    .n("ECSClient", "DescribeCapacityProvidersCommand")347    .sc(schemas_0.DescribeCapacityProviders$)348    .build() {349}350 351class DescribeClustersCommand extends client.Command352    .classBuilder()353    .ep(commonParams)354    .m(function (Command, cs, config, o) {355    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];356})357    .s("AmazonEC2ContainerServiceV20141113", "DescribeClusters", {})358    .n("ECSClient", "DescribeClustersCommand")359    .sc(schemas_0.DescribeClusters$)360    .build() {361}362 363class DescribeContainerInstancesCommand extends client.Command364    .classBuilder()365    .ep(commonParams)366    .m(function (Command, cs, config, o) {367    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];368})369    .s("AmazonEC2ContainerServiceV20141113", "DescribeContainerInstances", {})370    .n("ECSClient", "DescribeContainerInstancesCommand")371    .sc(schemas_0.DescribeContainerInstances$)372    .build() {373}374 375class DescribeDaemonCommand extends client.Command376    .classBuilder()377    .ep(commonParams)378    .m(function (Command, cs, config, o) {379    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];380})381    .s("AmazonEC2ContainerServiceV20141113", "DescribeDaemon", {})382    .n("ECSClient", "DescribeDaemonCommand")383    .sc(schemas_0.DescribeDaemon$)384    .build() {385}386 387class DescribeDaemonDeploymentsCommand extends client.Command388    .classBuilder()389    .ep(commonParams)390    .m(function (Command, cs, config, o) {391    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];392})393    .s("AmazonEC2ContainerServiceV20141113", "DescribeDaemonDeployments", {})394    .n("ECSClient", "DescribeDaemonDeploymentsCommand")395    .sc(schemas_0.DescribeDaemonDeployments$)396    .build() {397}398 399class DescribeDaemonRevisionsCommand extends client.Command400    .classBuilder()401    .ep(commonParams)402    .m(function (Command, cs, config, o) {403    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];404})405    .s("AmazonEC2ContainerServiceV20141113", "DescribeDaemonRevisions", {})406    .n("ECSClient", "DescribeDaemonRevisionsCommand")407    .sc(schemas_0.DescribeDaemonRevisions$)408    .build() {409}410 411class DescribeDaemonTaskDefinitionCommand extends client.Command412    .classBuilder()413    .ep(commonParams)414    .m(function (Command, cs, config, o) {415    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];416})417    .s("AmazonEC2ContainerServiceV20141113", "DescribeDaemonTaskDefinition", {})418    .n("ECSClient", "DescribeDaemonTaskDefinitionCommand")419    .sc(schemas_0.DescribeDaemonTaskDefinition$)420    .build() {421}422 423class DescribeExpressGatewayServiceCommand extends client.Command424    .classBuilder()425    .ep(commonParams)426    .m(function (Command, cs, config, o) {427    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];428})429    .s("AmazonEC2ContainerServiceV20141113", "DescribeExpressGatewayService", {})430    .n("ECSClient", "DescribeExpressGatewayServiceCommand")431    .sc(schemas_0.DescribeExpressGatewayService$)432    .build() {433}434 435class DescribeServiceDeploymentsCommand extends client.Command436    .classBuilder()437    .ep(commonParams)438    .m(function (Command, cs, config, o) {439    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];440})441    .s("AmazonEC2ContainerServiceV20141113", "DescribeServiceDeployments", {})442    .n("ECSClient", "DescribeServiceDeploymentsCommand")443    .sc(schemas_0.DescribeServiceDeployments$)444    .build() {445}446 447class DescribeServiceRevisionsCommand extends client.Command448    .classBuilder()449    .ep(commonParams)450    .m(function (Command, cs, config, o) {451    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];452})453    .s("AmazonEC2ContainerServiceV20141113", "DescribeServiceRevisions", {})454    .n("ECSClient", "DescribeServiceRevisionsCommand")455    .sc(schemas_0.DescribeServiceRevisions$)456    .build() {457}458 459class DescribeServicesCommand extends client.Command460    .classBuilder()461    .ep(commonParams)462    .m(function (Command, cs, config, o) {463    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];464})465    .s("AmazonEC2ContainerServiceV20141113", "DescribeServices", {})466    .n("ECSClient", "DescribeServicesCommand")467    .sc(schemas_0.DescribeServices$)468    .build() {469}470 471class DescribeTaskDefinitionCommand extends client.Command472    .classBuilder()473    .ep(commonParams)474    .m(function (Command, cs, config, o) {475    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];476})477    .s("AmazonEC2ContainerServiceV20141113", "DescribeTaskDefinition", {})478    .n("ECSClient", "DescribeTaskDefinitionCommand")479    .sc(schemas_0.DescribeTaskDefinition$)480    .build() {481}482 483class DescribeTasksCommand extends client.Command484    .classBuilder()485    .ep(commonParams)486    .m(function (Command, cs, config, o) {487    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];488})489    .s("AmazonEC2ContainerServiceV20141113", "DescribeTasks", {})490    .n("ECSClient", "DescribeTasksCommand")491    .sc(schemas_0.DescribeTasks$)492    .build() {493}494 495class DescribeTaskSetsCommand extends client.Command496    .classBuilder()497    .ep(commonParams)498    .m(function (Command, cs, config, o) {499    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];500})501    .s("AmazonEC2ContainerServiceV20141113", "DescribeTaskSets", {})502    .n("ECSClient", "DescribeTaskSetsCommand")503    .sc(schemas_0.DescribeTaskSets$)504    .build() {505}506 507class DiscoverPollEndpointCommand extends client.Command508    .classBuilder()509    .ep(commonParams)510    .m(function (Command, cs, config, o) {511    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];512})513    .s("AmazonEC2ContainerServiceV20141113", "DiscoverPollEndpoint", {})514    .n("ECSClient", "DiscoverPollEndpointCommand")515    .sc(schemas_0.DiscoverPollEndpoint$)516    .build() {517}518 519class ExecuteCommandCommand extends client.Command520    .classBuilder()521    .ep(commonParams)522    .m(function (Command, cs, config, o) {523    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];524})525    .s("AmazonEC2ContainerServiceV20141113", "ExecuteCommand", {})526    .n("ECSClient", "ExecuteCommandCommand")527    .sc(schemas_0.ExecuteCommand$)528    .build() {529}530 531class GetTaskProtectionCommand extends client.Command532    .classBuilder()533    .ep(commonParams)534    .m(function (Command, cs, config, o) {535    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];536})537    .s("AmazonEC2ContainerServiceV20141113", "GetTaskProtection", {})538    .n("ECSClient", "GetTaskProtectionCommand")539    .sc(schemas_0.GetTaskProtection$)540    .build() {541}542 543class ListAccountSettingsCommand extends client.Command544    .classBuilder()545    .ep(commonParams)546    .m(function (Command, cs, config, o) {547    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];548})549    .s("AmazonEC2ContainerServiceV20141113", "ListAccountSettings", {})550    .n("ECSClient", "ListAccountSettingsCommand")551    .sc(schemas_0.ListAccountSettings$)552    .build() {553}554 555class ListAttributesCommand extends client.Command556    .classBuilder()557    .ep(commonParams)558    .m(function (Command, cs, config, o) {559    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];560})561    .s("AmazonEC2ContainerServiceV20141113", "ListAttributes", {})562    .n("ECSClient", "ListAttributesCommand")563    .sc(schemas_0.ListAttributes$)564    .build() {565}566 567class ListClustersCommand extends client.Command568    .classBuilder()569    .ep(commonParams)570    .m(function (Command, cs, config, o) {571    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];572})573    .s("AmazonEC2ContainerServiceV20141113", "ListClusters", {})574    .n("ECSClient", "ListClustersCommand")575    .sc(schemas_0.ListClusters$)576    .build() {577}578 579class ListContainerInstancesCommand extends client.Command580    .classBuilder()581    .ep(commonParams)582    .m(function (Command, cs, config, o) {583    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];584})585    .s("AmazonEC2ContainerServiceV20141113", "ListContainerInstances", {})586    .n("ECSClient", "ListContainerInstancesCommand")587    .sc(schemas_0.ListContainerInstances$)588    .build() {589}590 591class ListDaemonDeploymentsCommand extends client.Command592    .classBuilder()593    .ep(commonParams)594    .m(function (Command, cs, config, o) {595    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];596})597    .s("AmazonEC2ContainerServiceV20141113", "ListDaemonDeployments", {})598    .n("ECSClient", "ListDaemonDeploymentsCommand")599    .sc(schemas_0.ListDaemonDeployments$)600    .build() {601}602 603class ListDaemonsCommand extends client.Command604    .classBuilder()605    .ep(commonParams)606    .m(function (Command, cs, config, o) {607    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];608})609    .s("AmazonEC2ContainerServiceV20141113", "ListDaemons", {})610    .n("ECSClient", "ListDaemonsCommand")611    .sc(schemas_0.ListDaemons$)612    .build() {613}614 615class ListDaemonTaskDefinitionsCommand extends client.Command616    .classBuilder()617    .ep(commonParams)618    .m(function (Command, cs, config, o) {619    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];620})621    .s("AmazonEC2ContainerServiceV20141113", "ListDaemonTaskDefinitions", {})622    .n("ECSClient", "ListDaemonTaskDefinitionsCommand")623    .sc(schemas_0.ListDaemonTaskDefinitions$)624    .build() {625}626 627class ListServiceDeploymentsCommand extends client.Command628    .classBuilder()629    .ep(commonParams)630    .m(function (Command, cs, config, o) {631    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];632})633    .s("AmazonEC2ContainerServiceV20141113", "ListServiceDeployments", {})634    .n("ECSClient", "ListServiceDeploymentsCommand")635    .sc(schemas_0.ListServiceDeployments$)636    .build() {637}638 639class ListServicesByNamespaceCommand extends client.Command640    .classBuilder()641    .ep(commonParams)642    .m(function (Command, cs, config, o) {643    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];644})645    .s("AmazonEC2ContainerServiceV20141113", "ListServicesByNamespace", {})646    .n("ECSClient", "ListServicesByNamespaceCommand")647    .sc(schemas_0.ListServicesByNamespace$)648    .build() {649}650 651class ListServicesCommand extends client.Command652    .classBuilder()653    .ep(commonParams)654    .m(function (Command, cs, config, o) {655    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];656})657    .s("AmazonEC2ContainerServiceV20141113", "ListServices", {})658    .n("ECSClient", "ListServicesCommand")659    .sc(schemas_0.ListServices$)660    .build() {661}662 663class ListTagsForResourceCommand extends client.Command664    .classBuilder()665    .ep(commonParams)666    .m(function (Command, cs, config, o) {667    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];668})669    .s("AmazonEC2ContainerServiceV20141113", "ListTagsForResource", {})670    .n("ECSClient", "ListTagsForResourceCommand")671    .sc(schemas_0.ListTagsForResource$)672    .build() {673}674 675class ListTaskDefinitionFamiliesCommand extends client.Command676    .classBuilder()677    .ep(commonParams)678    .m(function (Command, cs, config, o) {679    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];680})681    .s("AmazonEC2ContainerServiceV20141113", "ListTaskDefinitionFamilies", {})682    .n("ECSClient", "ListTaskDefinitionFamiliesCommand")683    .sc(schemas_0.ListTaskDefinitionFamilies$)684    .build() {685}686 687class ListTaskDefinitionsCommand extends client.Command688    .classBuilder()689    .ep(commonParams)690    .m(function (Command, cs, config, o) {691    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];692})693    .s("AmazonEC2ContainerServiceV20141113", "ListTaskDefinitions", {})694    .n("ECSClient", "ListTaskDefinitionsCommand")695    .sc(schemas_0.ListTaskDefinitions$)696    .build() {697}698 699class ListTasksCommand extends client.Command700    .classBuilder()701    .ep(commonParams)702    .m(function (Command, cs, config, o) {703    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];704})705    .s("AmazonEC2ContainerServiceV20141113", "ListTasks", {})706    .n("ECSClient", "ListTasksCommand")707    .sc(schemas_0.ListTasks$)708    .build() {709}710 711class PutAccountSettingCommand extends client.Command712    .classBuilder()713    .ep(commonParams)714    .m(function (Command, cs, config, o) {715    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];716})717    .s("AmazonEC2ContainerServiceV20141113", "PutAccountSetting", {})718    .n("ECSClient", "PutAccountSettingCommand")719    .sc(schemas_0.PutAccountSetting$)720    .build() {721}722 723class PutAccountSettingDefaultCommand extends client.Command724    .classBuilder()725    .ep(commonParams)726    .m(function (Command, cs, config, o) {727    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];728})729    .s("AmazonEC2ContainerServiceV20141113", "PutAccountSettingDefault", {})730    .n("ECSClient", "PutAccountSettingDefaultCommand")731    .sc(schemas_0.PutAccountSettingDefault$)732    .build() {733}734 735class PutAttributesCommand extends client.Command736    .classBuilder()737    .ep(commonParams)738    .m(function (Command, cs, config, o) {739    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];740})741    .s("AmazonEC2ContainerServiceV20141113", "PutAttributes", {})742    .n("ECSClient", "PutAttributesCommand")743    .sc(schemas_0.PutAttributes$)744    .build() {745}746 747class PutClusterCapacityProvidersCommand extends client.Command748    .classBuilder()749    .ep(commonParams)750    .m(function (Command, cs, config, o) {751    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];752})753    .s("AmazonEC2ContainerServiceV20141113", "PutClusterCapacityProviders", {})754    .n("ECSClient", "PutClusterCapacityProvidersCommand")755    .sc(schemas_0.PutClusterCapacityProviders$)756    .build() {757}758 759class RegisterContainerInstanceCommand extends client.Command760    .classBuilder()761    .ep(commonParams)762    .m(function (Command, cs, config, o) {763    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];764})765    .s("AmazonEC2ContainerServiceV20141113", "RegisterContainerInstance", {})766    .n("ECSClient", "RegisterContainerInstanceCommand")767    .sc(schemas_0.RegisterContainerInstance$)768    .build() {769}770 771class RegisterDaemonTaskDefinitionCommand extends client.Command772    .classBuilder()773    .ep(commonParams)774    .m(function (Command, cs, config, o) {775    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];776})777    .s("AmazonEC2ContainerServiceV20141113", "RegisterDaemonTaskDefinition", {})778    .n("ECSClient", "RegisterDaemonTaskDefinitionCommand")779    .sc(schemas_0.RegisterDaemonTaskDefinition$)780    .build() {781}782 783class RegisterTaskDefinitionCommand extends client.Command784    .classBuilder()785    .ep(commonParams)786    .m(function (Command, cs, config, o) {787    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];788})789    .s("AmazonEC2ContainerServiceV20141113", "RegisterTaskDefinition", {})790    .n("ECSClient", "RegisterTaskDefinitionCommand")791    .sc(schemas_0.RegisterTaskDefinition$)792    .build() {793}794 795class RunTaskCommand extends client.Command796    .classBuilder()797    .ep(commonParams)798    .m(function (Command, cs, config, o) {799    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];800})801    .s("AmazonEC2ContainerServiceV20141113", "RunTask", {})802    .n("ECSClient", "RunTaskCommand")803    .sc(schemas_0.RunTask$)804    .build() {805}806 807class StartTaskCommand extends client.Command808    .classBuilder()809    .ep(commonParams)810    .m(function (Command, cs, config, o) {811    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];812})813    .s("AmazonEC2ContainerServiceV20141113", "StartTask", {})814    .n("ECSClient", "StartTaskCommand")815    .sc(schemas_0.StartTask$)816    .build() {817}818 819class StopServiceDeploymentCommand extends client.Command820    .classBuilder()821    .ep(commonParams)822    .m(function (Command, cs, config, o) {823    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];824})825    .s("AmazonEC2ContainerServiceV20141113", "StopServiceDeployment", {})826    .n("ECSClient", "StopServiceDeploymentCommand")827    .sc(schemas_0.StopServiceDeployment$)828    .build() {829}830 831class StopTaskCommand extends client.Command832    .classBuilder()833    .ep(commonParams)834    .m(function (Command, cs, config, o) {835    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];836})837    .s("AmazonEC2ContainerServiceV20141113", "StopTask", {})838    .n("ECSClient", "StopTaskCommand")839    .sc(schemas_0.StopTask$)840    .build() {841}842 843class SubmitAttachmentStateChangesCommand extends client.Command844    .classBuilder()845    .ep(commonParams)846    .m(function (Command, cs, config, o) {847    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];848})849    .s("AmazonEC2ContainerServiceV20141113", "SubmitAttachmentStateChanges", {})850    .n("ECSClient", "SubmitAttachmentStateChangesCommand")851    .sc(schemas_0.SubmitAttachmentStateChanges$)852    .build() {853}854 855class SubmitContainerStateChangeCommand extends client.Command856    .classBuilder()857    .ep(commonParams)858    .m(function (Command, cs, config, o) {859    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];860})861    .s("AmazonEC2ContainerServiceV20141113", "SubmitContainerStateChange", {})862    .n("ECSClient", "SubmitContainerStateChangeCommand")863    .sc(schemas_0.SubmitContainerStateChange$)864    .build() {865}866 867class SubmitTaskStateChangeCommand extends client.Command868    .classBuilder()869    .ep(commonParams)870    .m(function (Command, cs, config, o) {871    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];872})873    .s("AmazonEC2ContainerServiceV20141113", "SubmitTaskStateChange", {})874    .n("ECSClient", "SubmitTaskStateChangeCommand")875    .sc(schemas_0.SubmitTaskStateChange$)876    .build() {877}878 879class TagResourceCommand extends client.Command880    .classBuilder()881    .ep(commonParams)882    .m(function (Command, cs, config, o) {883    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];884})885    .s("AmazonEC2ContainerServiceV20141113", "TagResource", {})886    .n("ECSClient", "TagResourceCommand")887    .sc(schemas_0.TagResource$)888    .build() {889}890 891class UntagResourceCommand extends client.Command892    .classBuilder()893    .ep(commonParams)894    .m(function (Command, cs, config, o) {895    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];896})897    .s("AmazonEC2ContainerServiceV20141113", "UntagResource", {})898    .n("ECSClient", "UntagResourceCommand")899    .sc(schemas_0.UntagResource$)900    .build() {901}902 903class UpdateCapacityProviderCommand extends client.Command904    .classBuilder()905    .ep(commonParams)906    .m(function (Command, cs, config, o) {907    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];908})909    .s("AmazonEC2ContainerServiceV20141113", "UpdateCapacityProvider", {})910    .n("ECSClient", "UpdateCapacityProviderCommand")911    .sc(schemas_0.UpdateCapacityProvider$)912    .build() {913}914 915class UpdateClusterCommand extends client.Command916    .classBuilder()917    .ep(commonParams)918    .m(function (Command, cs, config, o) {919    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];920})921    .s("AmazonEC2ContainerServiceV20141113", "UpdateCluster", {})922    .n("ECSClient", "UpdateClusterCommand")923    .sc(schemas_0.UpdateCluster$)924    .build() {925}926 927class UpdateClusterSettingsCommand extends client.Command928    .classBuilder()929    .ep(commonParams)930    .m(function (Command, cs, config, o) {931    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];932})933    .s("AmazonEC2ContainerServiceV20141113", "UpdateClusterSettings", {})934    .n("ECSClient", "UpdateClusterSettingsCommand")935    .sc(schemas_0.UpdateClusterSettings$)936    .build() {937}938 939class UpdateContainerAgentCommand extends client.Command940    .classBuilder()941    .ep(commonParams)942    .m(function (Command, cs, config, o) {943    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];944})945    .s("AmazonEC2ContainerServiceV20141113", "UpdateContainerAgent", {})946    .n("ECSClient", "UpdateContainerAgentCommand")947    .sc(schemas_0.UpdateContainerAgent$)948    .build() {949}950 951class UpdateContainerInstancesStateCommand extends client.Command952    .classBuilder()953    .ep(commonParams)954    .m(function (Command, cs, config, o) {955    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];956})957    .s("AmazonEC2ContainerServiceV20141113", "UpdateContainerInstancesState", {})958    .n("ECSClient", "UpdateContainerInstancesStateCommand")959    .sc(schemas_0.UpdateContainerInstancesState$)960    .build() {961}962 963class UpdateDaemonCommand extends client.Command964    .classBuilder()965    .ep(commonParams)966    .m(function (Command, cs, config, o) {967    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];968})969    .s("AmazonEC2ContainerServiceV20141113", "UpdateDaemon", {})970    .n("ECSClient", "UpdateDaemonCommand")971    .sc(schemas_0.UpdateDaemon$)972    .build() {973}974 975class UpdateExpressGatewayServiceCommand extends client.Command976    .classBuilder()977    .ep(commonParams)978    .m(function (Command, cs, config, o) {979    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];980})981    .s("AmazonEC2ContainerServiceV20141113", "UpdateExpressGatewayService", {})982    .n("ECSClient", "UpdateExpressGatewayServiceCommand")983    .sc(schemas_0.UpdateExpressGatewayService$)984    .build() {985}986 987class UpdateServiceCommand extends client.Command988    .classBuilder()989    .ep(commonParams)990    .m(function (Command, cs, config, o) {991    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];992})993    .s("AmazonEC2ContainerServiceV20141113", "UpdateService", {})994    .n("ECSClient", "UpdateServiceCommand")995    .sc(schemas_0.UpdateService$)996    .build() {997}998 999class UpdateServicePrimaryTaskSetCommand extends client.Command1000    .classBuilder()1001    .ep(commonParams)1002    .m(function (Command, cs, config, o) {1003    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];1004})1005    .s("AmazonEC2ContainerServiceV20141113", "UpdateServicePrimaryTaskSet", {})1006    .n("ECSClient", "UpdateServicePrimaryTaskSetCommand")1007    .sc(schemas_0.UpdateServicePrimaryTaskSet$)1008    .build() {1009}1010 1011class UpdateTaskProtectionCommand extends client.Command1012    .classBuilder()1013    .ep(commonParams)1014    .m(function (Command, cs, config, o) {1015    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];1016})1017    .s("AmazonEC2ContainerServiceV20141113", "UpdateTaskProtection", {})1018    .n("ECSClient", "UpdateTaskProtectionCommand")1019    .sc(schemas_0.UpdateTaskProtection$)1020    .build() {1021}1022 1023class UpdateTaskSetCommand extends client.Command1024    .classBuilder()1025    .ep(commonParams)1026    .m(function (Command, cs, config, o) {1027    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];1028})1029    .s("AmazonEC2ContainerServiceV20141113", "UpdateTaskSet", {})1030    .n("ECSClient", "UpdateTaskSetCommand")1031    .sc(schemas_0.UpdateTaskSet$)1032    .build() {1033}1034 1035const paginateListAccountSettings = core.createPaginator(ECSClient, ListAccountSettingsCommand, "nextToken", "nextToken", "maxResults");1036 1037const paginateListAttributes = core.createPaginator(ECSClient, ListAttributesCommand, "nextToken", "nextToken", "maxResults");1038 1039const paginateListClusters = core.createPaginator(ECSClient, ListClustersCommand, "nextToken", "nextToken", "maxResults");1040 1041const paginateListContainerInstances = core.createPaginator(ECSClient, ListContainerInstancesCommand, "nextToken", "nextToken", "maxResults");1042 1043const paginateListServicesByNamespace = core.createPaginator(ECSClient, ListServicesByNamespaceCommand, "nextToken", "nextToken", "maxResults");1044 1045const paginateListServices = core.createPaginator(ECSClient, ListServicesCommand, "nextToken", "nextToken", "maxResults");1046 1047const paginateListTaskDefinitionFamilies = core.createPaginator(ECSClient, ListTaskDefinitionFamiliesCommand, "nextToken", "nextToken", "maxResults");1048 1049const paginateListTaskDefinitions = core.createPaginator(ECSClient, ListTaskDefinitionsCommand, "nextToken", "nextToken", "maxResults");1050 1051const paginateListTasks = core.createPaginator(ECSClient, ListTasksCommand, "nextToken", "nextToken", "maxResults");1052 1053const checkState$8 = async (client$1, input) => {1054    let reason;1055    try {1056        let result = await client$1.send(new DescribeDaemonCommand(input));1057        reason = result;1058        try {1059            const returnComparator = () => {1060                return result.daemon.status;1061            };1062            if (returnComparator() === "ACTIVE") {1063                return { state: client.WaiterState.SUCCESS, reason };1064            }1065        }1066        catch (e) { }1067        try {1068            const returnComparator = () => {1069                return result.daemon.status;1070            };1071            if (returnComparator() === "DELETE_IN_PROGRESS") {1072                return { state: client.WaiterState.FAILURE, reason };1073            }1074        }1075        catch (e) { }1076    }1077    catch (exception) {1078        reason = exception;1079    }1080    return { state: client.WaiterState.RETRY, reason };1081};1082const waitForDaemonActive = async (params, input) => {1083    const serviceDefaults = { minDelay: 15, maxDelay: 120 };1084    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);1085};1086const waitUntilDaemonActive = async (params, input) => {1087    const serviceDefaults = { minDelay: 15, maxDelay: 120 };1088    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);1089    return client.checkExceptions(result);1090};1091 1092const checkState$7 = async (client$1, input) => {1093    let reason;1094    try {1095        let result = await client$1.send(new DescribeDaemonDeploymentsCommand(input));1096        reason = result;1097        try {1098            const returnComparator = () => {1099                let flat_1 = [].concat(...result.daemonDeployments);1100                let projection_3 = flat_1.map((element_2) => {1101                    return element_2.status;1102                });1103                return projection_3;1104            };1105            let allStringEq_5 = (returnComparator().length > 0);1106            for (let element_4 of returnComparator()) {1107                allStringEq_5 = allStringEq_5 && (element_4 == "STOPPED");1108            }1109            if (allStringEq_5) {1110                return { state: client.WaiterState.SUCCESS, reason };1111            }1112        }1113        catch (e) { }1114        try {1115            const returnComparator = () => {1116                let flat_1 = [].concat(...result.failures);1117                let projection_3 = flat_1.map((element_2) => {1118                    return element_2.reason;1119                });1120                return projection_3;1121            };1122            for (let anyStringEq_4 of returnComparator()) {1123                if (anyStringEq_4 == "MISSING") {1124                    return { state: client.WaiterState.FAILURE, reason };1125                }1126            }1127        }1128        catch (e) { }1129    }1130    catch (exception) {1131        reason = exception;1132    }1133    return { state: client.WaiterState.RETRY, reason };1134};1135const waitForDaemonDeploymentStopped = async (params, input) => {1136    const serviceDefaults = { minDelay: 15, maxDelay: 120 };1137    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);1138};1139const waitUntilDaemonDeploymentStopped = async (params, input) => {1140    const serviceDefaults = { minDelay: 15, maxDelay: 120 };1141    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);1142    return client.checkExceptions(result);1143};1144 1145const checkState$6 = async (client$1, input) => {1146    let reason;1147    try {1148        let result = await client$1.send(new DescribeDaemonDeploymentsCommand(input));1149        reason = result;1150        try {1151            const returnComparator = () => {1152                let flat_1 = [].concat(...result.daemonDeployments);1153                let projection_3 = flat_1.map((element_2) => {1154                    return element_2.status;1155                });1156                return projection_3;1157            };1158            let allStringEq_5 = (returnComparator().length > 0);1159            for (let element_4 of returnComparator()) {1160                allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESSFUL");1161            }1162            if (allStringEq_5) {1163                return { state: client.WaiterState.SUCCESS, reason };1164            }1165        }1166        catch (e) { }1167        try {1168            const returnComparator = () => {1169                let flat_1 = [].concat(...result.daemonDeployments);1170                let projection_3 = flat_1.map((element_2) => {1171                    return element_2.status;1172                });1173                return projection_3;1174            };1175            for (let anyStringEq_4 of returnComparator()) {1176                if (anyStringEq_4 == "STOPPED") {1177                    return { state: client.WaiterState.FAILURE, reason };1178                }1179            }1180        }1181        catch (e) { }1182        try {1183            const returnComparator = () => {1184                let flat_1 = [].concat(...result.daemonDeployments);1185                let projection_3 = flat_1.map((element_2) => {1186                    return element_2.status;1187                });1188                return projection_3;1189            };1190            for (let anyStringEq_4 of returnComparator()) {1191                if (anyStringEq_4 == "ROLLBACK_FAILED") {1192                    return { state: client.WaiterState.FAILURE, reason };1193                }1194            }1195        }1196        catch (e) { }1197        try {1198            const returnComparator = () => {1199                let flat_1 = [].concat(...result.daemonDeployments);1200                let projection_3 = flat_1.map((element_2) => {1201                    return element_2.status;1202                });1203                return projection_3;1204            };1205            for (let anyStringEq_4 of returnComparator()) {1206                if (anyStringEq_4 == "ROLLBACK_SUCCESSFUL") {1207                    return { state: client.WaiterState.FAILURE, reason };1208                }1209            }1210        }1211        catch (e) { }1212        try {1213            const returnComparator = () => {1214                let flat_1 = [].concat(...result.failures);1215                let projection_3 = flat_1.map((element_2) => {1216                    return element_2.reason;1217                });1218                return projection_3;1219            };1220            for (let anyStringEq_4 of returnComparator()) {1221                if (anyStringEq_4 == "MISSING") {1222                    return { state: client.WaiterState.FAILURE, reason };1223                }1224            }1225        }1226        catch (e) { }1227    }1228    catch (exception) {1229        reason = exception;1230    }1231    return { state: client.WaiterState.RETRY, reason };1232};1233const waitForDaemonDeploymentSuccessful = async (params, input) => {1234    const serviceDefaults = { minDelay: 15, maxDelay: 120 };1235    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);1236};1237const waitUntilDaemonDeploymentSuccessful = async (params, input) => {1238    const serviceDefaults = { minDelay: 15, maxDelay: 120 };1239    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);1240    return client.checkExceptions(result);1241};1242 1243const checkState$5 = async (client$1, input) => {1244    let reason;1245    try {1246        let result = await client$1.send(new DescribeDaemonTaskDefinitionCommand(input));1247        reason = result;1248        try {1249            const returnComparator = () => {1250                return result.daemonTaskDefinition.status;1251            };1252            if (returnComparator() === "ACTIVE") {1253                return { state: client.WaiterState.SUCCESS, reason };1254            }1255        }1256        catch (e) { }1257        try {1258            const returnComparator = () => {1259                return result.daemonTaskDefinition.status;1260            };1261            if (returnComparator() === "DELETE_IN_PROGRESS") {1262                return { state: client.WaiterState.FAILURE, reason };1263            }1264        }1265        catch (e) { }1266        try {1267            const returnComparator = () => {1268                return result.daemonTaskDefinition.status;1269            };1270            if (returnComparator() === "DELETED") {1271                return { state: client.WaiterState.FAILURE, reason };1272            }1273        }1274        catch (e) { }1275    }1276    catch (exception) {1277        reason = exception;1278    }1279    return { state: client.WaiterState.RETRY, reason };1280};1281const waitForDaemonTaskDefinitionActive = async (params, input) => {1282    const serviceDefaults = { minDelay: 15, maxDelay: 120 };1283    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);1284};1285const waitUntilDaemonTaskDefinitionActive = async (params, input) => {1286    const serviceDefaults = { minDelay: 15, maxDelay: 120 };1287    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);1288    return client.checkExceptions(result);1289};1290 1291const checkState$4 = async (client$1, input) => {1292    let reason;1293    try {1294        let result = await client$1.send(new DescribeDaemonTaskDefinitionCommand(input));1295        reason = result;1296        try {1297            const returnComparator = () => {1298                return result.daemonTaskDefinition.status;1299            };1300            if (returnComparator() === "DELETED") {1301                return { state: client.WaiterState.SUCCESS, reason };1302            }1303        }1304        catch (e) { }1305    }1306    catch (exception) {1307        reason = exception;1308    }1309    return { state: client.WaiterState.RETRY, reason };1310};1311const waitForDaemonTaskDefinitionDeleted = async (params, input) => {1312    const serviceDefaults = { minDelay: 15, maxDelay: 120 };1313    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);1314};1315const waitUntilDaemonTaskDefinitionDeleted = async (params, input) => {1316    const serviceDefaults = { minDelay: 15, maxDelay: 120 };1317    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);1318    return client.checkExceptions(result);1319};1320 1321const checkState$3 = async (client$1, input) => {1322    let reason;1323    try {1324        let result = await client$1.send(new DescribeServicesCommand(input));1325        reason = result;1326        try {1327            const returnComparator = () => {1328                let flat_1 = [].concat(...result.failures);1329                let projection_3 = flat_1.map((element_2) => {1330                    return element_2.reason;1331                });1332                return projection_3;1333            };1334            for (let anyStringEq_4 of returnComparator()) {1335                if (anyStringEq_4 == "MISSING") {1336                    return { state: client.WaiterState.FAILURE, reason };1337                }1338            }1339        }1340        catch (e) { }1341        try {1342            const returnComparator = () => {1343                let flat_1 = [].concat(...result.services);1344                let projection_3 = flat_1.map((element_2) => {1345                    return element_2.status;1346                });1347                return projection_3;1348            };1349            for (let anyStringEq_4 of returnComparator()) {1350                if (anyStringEq_4 == "INACTIVE") {1351                    return { state: client.WaiterState.SUCCESS, reason };1352                }1353            }1354        }1355        catch (e) { }1356    }1357    catch (exception) {1358        reason = exception;1359    }1360    return { state: client.WaiterState.RETRY, reason };1361};1362const waitForServicesInactive = async (params, input) => {1363    const serviceDefaults = { minDelay: 15, maxDelay: 600 };1364    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);1365};1366const waitUntilServicesInactive = async (params, input) => {1367    const serviceDefaults = { minDelay: 15, maxDelay: 600 };1368    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);1369    return client.checkExceptions(result);1370};1371 1372const checkState$2 = async (client$1, input) => {1373    let reason;1374    try {1375        let result = await client$1.send(new DescribeServicesCommand(input));1376        reason = result;1377        try {1378            const returnComparator = () => {1379                let flat_1 = [].concat(...result.failures);1380                let projection_3 = flat_1.map((element_2) => {1381                    return element_2.reason;1382                });1383                return projection_3;1384            };1385            for (let anyStringEq_4 of returnComparator()) {1386                if (anyStringEq_4 == "MISSING") {1387                    return { state: client.WaiterState.FAILURE, reason };1388                }1389            }1390        }1391        catch (e) { }1392        try {1393            const returnComparator = () => {1394                let flat_1 = [].concat(...result.services);1395                let projection_3 = flat_1.map((element_2) => {1396                    return element_2.status;1397                });1398                return projection_3;1399            };1400            for (let anyStringEq_4 of returnComparator()) {1401                if (anyStringEq_4 == "DRAINING") {1402                    return { state: client.WaiterState.FAILURE, reason };1403                }1404            }1405        }1406        catch (e) { }1407        try {1408            const returnComparator = () => {1409                let flat_1 = [].concat(...result.services);1410                let projection_3 = flat_1.map((element_2) => {1411                    return element_2.status;1412                });1413                return projection_3;1414            };1415            for (let anyStringEq_4 of returnComparator()) {1416                if (anyStringEq_4 == "INACTIVE") {1417                    return { state: client.WaiterState.FAILURE, reason };1418                }1419            }1420        }1421        catch (e) { }1422        try {1423            const returnComparator = () => {1424                let filterRes_2 = result.services.filter((element_1) => {1425                    return (!((element_1.deployments.length == 1) && (element_1.runningCount == element_1.desiredCount)));1426                });1427                return (filterRes_2.length == 0);1428            };1429            if (returnComparator() == true) {1430                return { state: client.WaiterState.SUCCESS, reason };1431            }1432        }1433        catch (e) { }1434    }1435    catch (exception) {1436        reason = exception;1437    }1438    return { state: client.WaiterState.RETRY, reason };1439};1440const waitForServicesStable = async (params, input) => {1441    const serviceDefaults = { minDelay: 15, maxDelay: 600 };1442    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);1443};1444const waitUntilServicesStable = async (params, input) => {1445    const serviceDefaults = { minDelay: 15, maxDelay: 600 };1446    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);1447    return client.checkExceptions(result);1448};1449 1450const checkState$1 = async (client$1, input) => {1451    let reason;1452    try {1453        let result = await client$1.send(new DescribeTasksCommand(input));1454        reason = result;1455        try {1456            const returnComparator = () => {1457                let flat_1 = [].concat(...result.tasks);1458                let projection_3 = flat_1.map((element_2) => {1459                    return element_2.lastStatus;1460                });1461                return projection_3;1462            };1463            for (let anyStringEq_4 of returnComparator()) {1464                if (anyStringEq_4 == "STOPPED") {1465                    return { state: client.WaiterState.FAILURE, reason };1466                }1467            }1468        }1469        catch (e) { }1470        try {1471            const returnComparator = () => {1472                let flat_1 = [].concat(...result.failures);1473                let projection_3 = flat_1.map((element_2) => {1474                    return element_2.reason;1475                });1476                return projection_3;1477            };1478            for (let anyStringEq_4 of returnComparator()) {1479                if (anyStringEq_4 == "MISSING") {1480                    return { state: client.WaiterState.FAILURE, reason };1481                }1482            }1483        }1484        catch (e) { }1485        try {1486            const returnComparator = () => {1487                let flat_1 = [].concat(...result.tasks);1488                let projection_3 = flat_1.map((element_2) => {1489                    return element_2.lastStatus;1490                });1491                return projection_3;1492            };1493            let allStringEq_5 = (returnComparator().length > 0);1494            for (let element_4 of returnComparator()) {1495                allStringEq_5 = allStringEq_5 && (element_4 == "RUNNING");1496            }1497            if (allStringEq_5) {1498                return { state: client.WaiterState.SUCCESS, reason };1499            }1500        }1501        catch (e) { }1502    }1503    catch (exception) {1504        reason = exception;1505    }1506    return { state: client.WaiterState.RETRY, reason };1507};1508const waitForTasksRunning = async (params, input) => {1509    const serviceDefaults = { minDelay: 6, maxDelay: 600 };1510    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);1511};1512const waitUntilTasksRunning = async (params, input) => {1513    const serviceDefaults = { minDelay: 6, maxDelay: 600 };1514    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);1515    return client.checkExceptions(result);1516};1517 1518const checkState = async (client$1, input) => {1519    let reason;1520    try {1521        let result = await client$1.send(new DescribeTasksCommand(input));1522        reason = result;1523        try {1524            const returnComparator = () => {1525                let flat_1 = [].concat(...result.tasks);1526                let projection_3 = flat_1.map((element_2) => {1527                    return element_2.lastStatus;1528                });1529                return projection_3;1530            };1531            let allStringEq_5 = (returnComparator().length > 0);1532            for (let element_4 of returnComparator()) {1533                allStringEq_5 = allStringEq_5 && (element_4 == "STOPPED");1534            }1535            if (allStringEq_5) {1536                return { state: client.WaiterState.SUCCESS, reason };1537            }1538        }1539        catch (e) { }1540    }1541    catch (exception) {1542        reason = exception;1543    }1544    return { state: client.WaiterState.RETRY, reason };1545};1546const waitForTasksStopped = async (params, input) => {1547    const serviceDefaults = { minDelay: 6, maxDelay: 600 };1548    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);1549};1550const waitUntilTasksStopped = async (params, input) => {1551    const serviceDefaults = { minDelay: 6, maxDelay: 600 };1552    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);1553    return client.checkExceptions(result);1554};1555 1556const commands = {1557    ContinueServiceDeploymentCommand,1558    CreateCapacityProviderCommand,1559    CreateClusterCommand,1560    CreateDaemonCommand,1561    CreateExpressGatewayServiceCommand,1562    CreateServiceCommand,1563    CreateTaskSetCommand,1564    DeleteAccountSettingCommand,1565    DeleteAttributesCommand,1566    DeleteCapacityProviderCommand,1567    DeleteClusterCommand,1568    DeleteDaemonCommand,1569    DeleteDaemonTaskDefinitionCommand,1570    DeleteExpressGatewayServiceCommand,1571    DeleteServiceCommand,1572    DeleteTaskDefinitionsCommand,1573    DeleteTaskSetCommand,1574    DeregisterContainerInstanceCommand,1575    DeregisterTaskDefinitionCommand,1576    DescribeCapacityProvidersCommand,1577    DescribeClustersCommand,1578    DescribeContainerInstancesCommand,1579    DescribeDaemonCommand,1580    DescribeDaemonDeploymentsCommand,1581    DescribeDaemonRevisionsCommand,1582    DescribeDaemonTaskDefinitionCommand,1583    DescribeExpressGatewayServiceCommand,1584    DescribeServiceDeploymentsCommand,1585    DescribeServiceRevisionsCommand,1586    DescribeServicesCommand,1587    DescribeTaskDefinitionCommand,1588    DescribeTasksCommand,1589    DescribeTaskSetsCommand,1590    DiscoverPollEndpointCommand,1591    ExecuteCommandCommand,1592    GetTaskProtectionCommand,1593    ListAccountSettingsCommand,1594    ListAttributesCommand,1595    ListClustersCommand,1596    ListContainerInstancesCommand,1597    ListDaemonDeploymentsCommand,1598    ListDaemonsCommand,1599    ListDaemonTaskDefinitionsCommand,1600    ListServiceDeploymentsCommand,1601    ListServicesCommand,1602    ListServicesByNamespaceCommand,1603    ListTagsForResourceCommand,1604    ListTaskDefinitionFamiliesCommand,1605    ListTaskDefinitionsCommand,1606    ListTasksCommand,1607    PutAccountSettingCommand,1608    PutAccountSettingDefaultCommand,1609    PutAttributesCommand,1610    PutClusterCapacityProvidersCommand,1611    RegisterContainerInstanceCommand,1612    RegisterDaemonTaskDefinitionCommand,1613    RegisterTaskDefinitionCommand,1614    RunTaskCommand,1615    StartTaskCommand,1616    StopServiceDeploymentCommand,1617    StopTaskCommand,1618    SubmitAttachmentStateChangesCommand,1619    SubmitContainerStateChangeCommand,1620    SubmitTaskStateChangeCommand,1621    TagResourceCommand,1622    UntagResourceCommand,1623    UpdateCapacityProviderCommand,1624    UpdateClusterCommand,1625    UpdateClusterSettingsCommand,1626    UpdateContainerAgentCommand,1627    UpdateContainerInstancesStateCommand,1628    UpdateDaemonCommand,1629    UpdateExpressGatewayServiceCommand,1630    UpdateServiceCommand,1631    UpdateServicePrimaryTaskSetCommand,1632    UpdateTaskProtectionCommand,1633    UpdateTaskSetCommand,1634};1635const paginators = {1636    paginateListAccountSettings,1637    paginateListAttributes,1638    paginateListClusters,1639    paginateListContainerInstances,1640    paginateListServices,1641    paginateListServicesByNamespace,1642    paginateListTaskDefinitionFamilies,1643    paginateListTaskDefinitions,1644    paginateListTasks,1645};1646const waiters = {1647    waitUntilDaemonActive,1648    waitUntilDaemonDeploymentSuccessful,1649    waitUntilDaemonDeploymentStopped,1650    waitUntilDaemonTaskDefinitionActive,1651    waitUntilDaemonTaskDefinitionDeleted,1652    waitUntilServicesInactive,1653    waitUntilServicesStable,1654    waitUntilTasksRunning,1655    waitUntilTasksStopped,1656};1657class ECS extends ECSClient {1658}1659client.createAggregatedClient(commands, ECS, { paginators, waiters });1660 1661const AcceleratorManufacturer = {1662    AMAZON_WEB_SERVICES: "amazon-web-services",1663    AMD: "amd",1664    HABANA: "habana",1665    NVIDIA: "nvidia",1666    XILINX: "xilinx",1667};1668const AcceleratorName = {1669    A100: "a100",1670    A10G: "a10g",1671    H100: "h100",1672    INFERENTIA: "inferentia",1673    K520: "k520",1674    K80: "k80",1675    M60: "m60",1676    RADEON_PRO_V520: "radeon-pro-v520",1677    T4: "t4",1678    T4G: "t4g",1679    V100: "v100",1680    VU9P: "vu9p",1681};1682const AcceleratorType = {1683    FPGA: "fpga",1684    GPU: "gpu",1685    INFERENCE: "inference",1686};1687const AccessType = {1688    PRIVATE: "PRIVATE",1689    PUBLIC: "PUBLIC",1690};1691const AgentUpdateStatus = {1692    FAILED: "FAILED",1693    PENDING: "PENDING",1694    STAGED: "STAGED",1695    STAGING: "STAGING",1696    UPDATED: "UPDATED",1697    UPDATING: "UPDATING",1698};1699const ManagedDraining = {1700    DISABLED: "DISABLED",1701    ENABLED: "ENABLED",1702};1703const ManagedScalingStatus = {1704    DISABLED: "DISABLED",1705    ENABLED: "ENABLED",1706};1707const ManagedTerminationProtection = {1708    DISABLED: "DISABLED",1709    ENABLED: "ENABLED",1710};1711const AutoRepairActionsStatus = {1712    DISABLED: "DISABLED",1713    ENABLED: "ENABLED",1714};1715const CapacityOptionType = {1716    ON_DEMAND: "ON_DEMAND",1717    RESERVED: "RESERVED",1718    SPOT: "SPOT",1719};1720const CapacityReservationPreference = {1721    RESERVATIONS_EXCLUDED: "RESERVATIONS_EXCLUDED",1722    RESERVATIONS_FIRST: "RESERVATIONS_FIRST",1723    RESERVATIONS_ONLY: "RESERVATIONS_ONLY",1724};1725const BareMetal = {1726    EXCLUDED: "excluded",1727    INCLUDED: "included",1728    REQUIRED: "required",1729};1730const BurstablePerformance = {1731    EXCLUDED: "excluded",1732    INCLUDED: "included",1733    REQUIRED: "required",1734};1735const CpuManufacturer = {1736    AMAZON_WEB_SERVICES: "amazon-web-services",1737    AMD: "amd",1738    INTEL: "intel",1739};1740const InstanceGeneration = {1741    CURRENT: "current",1742    PREVIOUS: "previous",1743};1744const LocalStorage = {1745    EXCLUDED: "excluded",1746    INCLUDED: "included",1747    REQUIRED: "required",1748};1749const LocalStorageType = {1750    HDD: "hdd",1751    SSD: "ssd",1752};1753const ManagedInstancesMonitoringOptions = {1754    BASIC: "BASIC",1755    DETAILED: "DETAILED",1756};1757const PropagateMITags = {1758    CAPACITY_PROVIDER: "CAPACITY_PROVIDER",1759    NONE: "NONE",1760};1761const CapacityProviderStatus = {1762    ACTIVE: "ACTIVE",1763    DEPROVISIONING: "DEPROVISIONING",1764    INACTIVE: "INACTIVE",1765    PROVISIONING: "PROVISIONING",1766};1767const CapacityProviderType = {1768    EC2_AUTOSCALING: "EC2_AUTOSCALING",1769    FARGATE: "FARGATE",1770    FARGATE_SPOT: "FARGATE_SPOT",1771    MANAGED_INSTANCES: "MANAGED_INSTANCES",1772};1773const CapacityProviderUpdateStatus = {1774    CREATE_COMPLETE: "CREATE_COMPLETE",1775    CREATE_FAILED: "CREATE_FAILED",1776    CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",1777    DELETE_COMPLETE: "DELETE_COMPLETE",1778    DELETE_FAILED: "DELETE_FAILED",1779    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",1780    UPDATE_COMPLETE: "UPDATE_COMPLETE",1781    UPDATE_FAILED: "UPDATE_FAILED",1782    UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",1783};1784const CapacityProviderField = {1785    TAGS: "TAGS",1786};1787const ExecuteCommandLogging = {1788    DEFAULT: "DEFAULT",1789    NONE: "NONE",1790    OVERRIDE: "OVERRIDE",1791};1792const ClusterSettingName = {1793    CONTAINER_INSIGHTS: "containerInsights",1794};1795const TargetType = {1796    CONTAINER_INSTANCE: "container-instance",1797};1798const InstanceHealthCheckState = {1799    IMPAIRED: "IMPAIRED",1800    INITIALIZING: "INITIALIZING",1801    INSUFFICIENT_DATA: "INSUFFICIENT_DATA",1802    OK: "OK",1803};1804const InstanceHealthCheckType = {1805    ACCELERATED_COMPUTE: "ACCELERATED_COMPUTE",1806    CONTAINER_RUNTIME: "CONTAINER_RUNTIME",1807    DAEMON: "DAEMON",1808};1809const ClusterField = {1810    ATTACHMENTS: "ATTACHMENTS",1811    CONFIGURATIONS: "CONFIGURATIONS",1812    SETTINGS: "SETTINGS",1813    STATISTICS: "STATISTICS",1814    TAGS: "TAGS",1815};1816const ContainerInstanceStatus = {1817    ACTIVE: "ACTIVE",1818    DEREGISTERING: "DEREGISTERING",1819    DRAINING: "DRAINING",1820    REGISTERING: "REGISTERING",1821    REGISTRATION_FAILED: "REGISTRATION_FAILED",1822};1823const TransportProtocol = {1824    TCP: "tcp",1825    UDP: "udp",1826};1827const ManagedAgentName = {1828    ExecuteCommandAgent: "ExecuteCommandAgent",1829};1830const ContainerInstanceField = {1831    CONTAINER_INSTANCE_HEALTH: "CONTAINER_INSTANCE_HEALTH",1832    TAGS: "TAGS",1833};1834const DesiredStatus = {1835    PENDING: "PENDING",1836    RUNNING: "RUNNING",1837    STOPPED: "STOPPED",1838};1839const LaunchType = {1840    EC2: "EC2",1841    EXTERNAL: "EXTERNAL",1842    FARGATE: "FARGATE",1843    MANAGED_INSTANCES: "MANAGED_INSTANCES",1844};1845const PlatformDeviceType = {1846    GPU: "GPU",1847};1848const DeploymentLifecycleHookAction = {1849    CONTINUE: "CONTINUE",1850    ROLLBACK: "ROLLBACK",1851};1852const DaemonDeploymentRollbackMonitorsStatus = {1853    DISABLED: "DISABLED",1854    MONITORING: "MONITORING",1855    MONITORING_COMPLETE: "MONITORING_COMPLETE",1856    TRIGGERED: "TRIGGERED",1857};1858const DaemonDeploymentStatus = {1859    IN_PROGRESS: "IN_PROGRESS",1860    PENDING: "PENDING",1861    ROLLBACK_FAILED: "ROLLBACK_FAILED",1862    ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS",1863    ROLLBACK_SUCCESSFUL: "ROLLBACK_SUCCESSFUL",1864    STOPPED: "STOPPED",1865    STOP_REQUESTED: "STOP_REQUESTED",1866    SUCCESSFUL: "SUCCESSFUL",1867};1868const DaemonPropagateTags = {1869    DAEMON: "DAEMON",1870    NONE: "NONE",1871};1872const DaemonStatus = {1873    ACTIVE: "ACTIVE",1874    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",1875};1876const ContainerCondition = {1877    COMPLETE: "COMPLETE",1878    HEALTHY: "HEALTHY",1879    START: "START",1880    SUCCESS: "SUCCESS",1881};1882const EnvironmentFileType = {1883    S3: "s3",1884};1885const FirelensConfigurationType = {1886    FLUENTBIT: "fluentbit",1887    FLUENTD: "fluentd",1888};1889const DeviceCgroupPermission = {1890    MKNOD: "mknod",1891    READ: "read",1892    WRITE: "write",1893};1894const LogDriver = {1895    AWSFIRELENS: "awsfirelens",1896    AWSLOGS: "awslogs",1897    FLUENTD: "fluentd",1898    GELF: "gelf",1899    JOURNALD: "journald",1900    JSON_FILE: "json-file",1901    SPLUNK: "splunk",1902    SYSLOG: "syslog",1903};1904const UlimitName = {1905    CORE: "core",1906    CPU: "cpu",1907    DATA: "data",1908    FSIZE: "fsize",1909    LOCKS: "locks",1910    MEMLOCK: "memlock",1911    MSGQUEUE: "msgqueue",1912    NICE: "nice",1913    NOFILE: "nofile",1914    NPROC: "nproc",1915    RSS: "rss",1916    RTPRIO: "rtprio",1917    RTTIME: "rttime",1918    SIGPENDING: "sigpending",1919    STACK: "stack",1920};1921const DaemonTaskDefinitionStatus = {1922    ACTIVE: "ACTIVE",1923    DELETED: "DELETED",1924    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",1925};1926const DaemonTaskDefinitionRevisionFilter = {1927    LAST_REGISTERED: "LAST_REGISTERED",1928};1929const SortOrder = {1930    ASC: "ASC",1931    DESC: "DESC",1932};1933const DaemonTaskDefinitionStatusFilter = {1934    ACTIVE: "ACTIVE",1935    ALL: "ALL",1936    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",1937};1938const SettingName = {1939    AWSVPC_TRUNKING: "awsvpcTrunking",1940    CONTAINER_INSIGHTS: "containerInsights",1941    CONTAINER_INSTANCE_LONG_ARN_FORMAT: "containerInstanceLongArnFormat",1942    DEFAULT_LOG_DRIVER_MODE: "defaultLogDriverMode",1943    FARGATE_EVENT_WINDOWS: "fargateEventWindows",1944    FARGATE_FIPS_MODE: "fargateFIPSMode",1945    FARGATE_TASK_RETIREMENT_WAIT_PERIOD: "fargateTaskRetirementWaitPeriod",1946    GUARD_DUTY_ACTIVATE: "guardDutyActivate",1947    SERVICE_LONG_ARN_FORMAT: "serviceLongArnFormat",1948    TAG_RESOURCE_AUTHORIZATION: "tagResourceAuthorization",1949    TASK_LONG_ARN_FORMAT: "taskLongArnFormat",1950};1951const SettingType = {1952    AWS_MANAGED: "aws_managed",1953    USER: "user",1954};1955const Compatibility = {1956    EC2: "EC2",1957    EXTERNAL: "EXTERNAL",1958    FARGATE: "FARGATE",1959    MANAGED_INSTANCES: "MANAGED_INSTANCES",1960};1961const ApplicationProtocol = {1962    GRPC: "grpc",1963    HTTP: "http",1964    HTTP2: "http2",1965};1966const ResourceType = {1967    GPU: "GPU",1968    INFERENCE_ACCELERATOR: "InferenceAccelerator",1969};1970const VersionConsistency = {1971    DISABLED: "disabled",1972    ENABLED: "enabled",1973};1974const IpcMode = {1975    HOST: "host",1976    NONE: "none",1977    TASK: "task",1978};1979const NetworkMode = {1980    AWSVPC: "awsvpc",1981    BRIDGE: "bridge",1982    HOST: "host",1983    NONE: "none",1984};1985const PidMode = {1986    HOST: "host",1987    TASK: "task",1988};1989const TaskDefinitionPlacementConstraintType = {1990    MEMBER_OF: "memberOf",1991};1992const ProxyConfigurationType = {1993    APPMESH: "APPMESH",1994};1995const CPUArchitecture = {1996    ARM64: "ARM64",1997    X86_64: "X86_64",1998};1999const OSFamily = {2000    LINUX: "LINUX",2001    WINDOWS_SERVER_2004_CORE: "WINDOWS_SERVER_2004_CORE",2002    WINDOWS_SERVER_2016_FULL: "WINDOWS_SERVER_2016_FULL",2003    WINDOWS_SERVER_2019_CORE: "WINDOWS_SERVER_2019_CORE",2004    WINDOWS_SERVER_2019_FULL: "WINDOWS_SERVER_2019_FULL",2005    WINDOWS_SERVER_2022_CORE: "WINDOWS_SERVER_2022_CORE",2006    WINDOWS_SERVER_2022_FULL: "WINDOWS_SERVER_2022_FULL",2007    WINDOWS_SERVER_2025_CORE: "WINDOWS_SERVER_2025_CORE",2008    WINDOWS_SERVER_2025_FULL: "WINDOWS_SERVER_2025_FULL",2009    WINDOWS_SERVER_20H2_CORE: "WINDOWS_SERVER_20H2_CORE",2010};2011const TaskDefinitionStatus = {2012    ACTIVE: "ACTIVE",2013    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",2014    INACTIVE: "INACTIVE",2015};2016const Scope = {2017    SHARED: "shared",2018    TASK: "task",2019};2020const EFSAuthorizationConfigIAM = {2021    DISABLED: "DISABLED",2022    ENABLED: "ENABLED",2023};2024const EFSTransitEncryption = {2025    DISABLED: "DISABLED",2026    ENABLED: "ENABLED",2027};2028const TaskDefinitionField = {2029    TAGS: "TAGS",2030};2031const TaskDefinitionFamilyStatus = {2032    ACTIVE: "ACTIVE",2033    ALL: "ALL",2034    INACTIVE: "INACTIVE",2035};2036const ServiceDeploymentRollbackMonitorsStatus = {2037    DISABLED: "DISABLED",2038    MONITORING: "MONITORING",2039    MONITORING_COMPLETE: "MONITORING_COMPLETE",2040    TRIGGERED: "TRIGGERED",2041};2042const DeploymentLifecycleHookStage = {2043    POST_PRODUCTION_TRAFFIC_SHIFT: "POST_PRODUCTION_TRAFFIC_SHIFT",2044    POST_SCALE_UP: "POST_SCALE_UP",2045    POST_TEST_TRAFFIC_SHIFT: "POST_TEST_TRAFFIC_SHIFT",2046    PRE_PRODUCTION_TRAFFIC_SHIFT: "PRE_PRODUCTION_TRAFFIC_SHIFT",2047    PRE_SCALE_UP: "PRE_SCALE_UP",2048    PRODUCTION_TRAFFIC_SHIFT: "PRODUCTION_TRAFFIC_SHIFT",2049    RECONCILE_SERVICE: "RECONCILE_SERVICE",2050    TEST_TRAFFIC_SHIFT: "TEST_TRAFFIC_SHIFT",2051};2052const DeploymentLifecycleHookTargetType = {2053    AWS_LAMBDA: "AWS_LAMBDA",2054    PAUSE: "PAUSE",2055};2056const DeploymentStrategy = {2057    BLUE_GREEN: "BLUE_GREEN",2058    CANARY: "CANARY",2059    LINEAR: "LINEAR",2060    ROLLING: "ROLLING",2061};2062const DeploymentLifecycleHookStatus = {2063    AWAITING_ACTION: "AWAITING_ACTION",2064    FAILED: "FAILED",2065    IN_PROGRESS: "IN_PROGRESS",2066    SUCCEEDED: "SUCCEEDED",2067    TIMED_OUT: "TIMED_OUT",2068};2069const ServiceDeploymentLifecycleStage = {2070    BAKE_TIME: "BAKE_TIME",2071    CLEAN_UP: "CLEAN_UP",2072    POST_PRODUCTION_TRAFFIC_SHIFT: "POST_PRODUCTION_TRAFFIC_SHIFT",2073    POST_SCALE_UP: "POST_SCALE_UP",2074    POST_TEST_TRAFFIC_SHIFT: "POST_TEST_TRAFFIC_SHIFT",2075    PRE_SCALE_UP: "PRE_SCALE_UP",2076    PRODUCTION_TRAFFIC_SHIFT: "PRODUCTION_TRAFFIC_SHIFT",2077    RECONCILE_SERVICE: "RECONCILE_SERVICE",2078    SCALE_UP: "SCALE_UP",2079    TEST_TRAFFIC_SHIFT: "TEST_TRAFFIC_SHIFT",2080};2081const ServiceDeploymentStatus = {2082    IN_PROGRESS: "IN_PROGRESS",2083    PENDING: "PENDING",2084    ROLLBACK_FAILED: "ROLLBACK_FAILED",2085    ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS",2086    ROLLBACK_REQUESTED: "ROLLBACK_REQUESTED",2087    ROLLBACK_SUCCESSFUL: "ROLLBACK_SUCCESSFUL",2088    STOPPED: "STOPPED",2089    STOP_REQUESTED: "STOP_REQUESTED",2090    SUCCESSFUL: "SUCCESSFUL",2091};2092const ExpressGatewayServiceScalingMetric = {2093    AverageCPUUtilization: "AVERAGE_CPU",2094    AverageMemoryUtilization: "AVERAGE_MEMORY",2095    RequestCountPerTarget: "REQUEST_COUNT_PER_TARGET",2096};2097const ExpressGatewayServiceStatusCode = {2098    ACTIVE: "ACTIVE",2099    DRAINING: "DRAINING",2100    INACTIVE: "INACTIVE",2101};2102const AvailabilityZoneRebalancing = {2103    DISABLED: "DISABLED",2104    ENABLED: "ENABLED",2105};2106const DeploymentControllerType = {2107    CODE_DEPLOY: "CODE_DEPLOY",2108    ECS: "ECS",2109    EXTERNAL: "EXTERNAL",2110};2111const AssignPublicIp = {2112    DISABLED: "DISABLED",2113    ENABLED: "ENABLED",2114};2115const PlacementConstraintType = {2116    DISTINCT_INSTANCE: "distinctInstance",2117    MEMBER_OF: "memberOf",2118};2119const PlacementStrategyType = {2120    BINPACK: "binpack",2121    RANDOM: "random",2122    SPREAD: "spread",2123};2124const PropagateTags = {2125    NONE: "NONE",2126    SERVICE: "SERVICE",2127    TASK_DEFINITION: "TASK_DEFINITION",2128};2129const SchedulingStrategy = {2130    DAEMON: "DAEMON",2131    REPLICA: "REPLICA",2132};2133const ServiceConnectAccessLoggingFormat = {2134    JSON: "JSON",2135    TEXT: "TEXT",2136};2137const ServiceConnectIncludeQueryParameters = {2138    DISABLED: "DISABLED",2139    ENABLED: "ENABLED",2140};2141const TaskFilesystemType = {2142    EXT3: "ext3",2143    EXT4: "ext4",2144    NTFS: "ntfs",2145    XFS: "xfs",2146};2147const EBSResourceType = {2148    VOLUME: "volume",2149};2150const DeploymentRolloutState = {2151    COMPLETED: "COMPLETED",2152    FAILED: "FAILED",2153    IN_PROGRESS: "IN_PROGRESS",2154};2155const ResourceManagementType = {2156    CUSTOMER: "CUSTOMER",2157    ECS: "ECS",2158};2159const ScaleUnit = {2160    PERCENT: "PERCENT",2161};2162const StabilityStatus = {2163    STABILIZING: "STABILIZING",2164    STEADY_STATE: "STEADY_STATE",2165};2166const ExpressGatewayServiceInclude = {2167    TAGS: "TAGS",2168};2169const ServiceField = {2170    TAGS: "TAGS",2171};2172const StopServiceDeploymentStopType = {2173    ABORT: "ABORT",2174    ROLLBACK: "ROLLBACK",2175};2176const ManagedResourceStatus = {2177    ACTIVE: "ACTIVE",2178    DELETED: "DELETED",2179    DEPROVISIONING: "DEPROVISIONING",2180    FAILED: "FAILED",2181    PROVISIONING: "PROVISIONING",2182};2183const TaskField = {2184    TAGS: "TAGS",2185};2186const Connectivity = {2187    CONNECTED: "CONNECTED",2188    DISCONNECTED: "DISCONNECTED",2189};2190const HealthStatus = {2191    HEALTHY: "HEALTHY",2192    UNHEALTHY: "UNHEALTHY",2193    UNKNOWN: "UNKNOWN",2194};2195const TaskStopCode = {2196    ESSENTIAL_CONTAINER_EXITED: "EssentialContainerExited",2197    SERVICE_SCHEDULER_INITIATED: "ServiceSchedulerInitiated",2198    SPOT_INTERRUPTION: "SpotInterruption",2199    TASK_FAILED_TO_START: "TaskFailedToStart",2200    TERMINATION_NOTICE: "TerminationNotice",2201    USER_INITIATED: "UserInitiated",2202};2203const TaskSetField = {2204    TAGS: "TAGS",2205};2206 2207exports.$Command = client.Command;2208exports.__Client = client.Client;2209exports.ECSServiceException = ECSServiceException.ECSServiceException;2210exports.AcceleratorManufacturer = AcceleratorManufacturer;2211exports.AcceleratorName = AcceleratorName;2212exports.AcceleratorType = AcceleratorType;2213exports.AccessType = AccessType;2214exports.AgentUpdateStatus = AgentUpdateStatus;2215exports.ApplicationProtocol = ApplicationProtocol;2216exports.AssignPublicIp = AssignPublicIp;2217exports.AutoRepairActionsStatus = AutoRepairActionsStatus;2218exports.AvailabilityZoneRebalancing = AvailabilityZoneRebalancing;2219exports.BareMetal = BareMetal;2220exports.BurstablePerformance = BurstablePerformance;2221exports.CPUArchitecture = CPUArchitecture;2222exports.CapacityOptionType = CapacityOptionType;2223exports.CapacityProviderField = CapacityProviderField;2224exports.CapacityProviderStatus = CapacityProviderStatus;2225exports.CapacityProviderType = CapacityProviderType;2226exports.CapacityProviderUpdateStatus = CapacityProviderUpdateStatus;2227exports.CapacityReservationPreference = CapacityReservationPreference;2228exports.ClusterField = ClusterField;2229exports.ClusterSettingName = ClusterSettingName;2230exports.Compatibility = Compatibility;2231exports.Connectivity = Connectivity;2232exports.ContainerCondition = ContainerCondition;2233exports.ContainerInstanceField = ContainerInstanceField;2234exports.ContainerInstanceStatus = ContainerInstanceStatus;2235exports.ContinueServiceDeploymentCommand = ContinueServiceDeploymentCommand;2236exports.CpuManufacturer = CpuManufacturer;2237exports.CreateCapacityProviderCommand = CreateCapacityProviderCommand;2238exports.CreateClusterCommand = CreateClusterCommand;2239exports.CreateDaemonCommand = CreateDaemonCommand;2240exports.CreateExpressGatewayServiceCommand = CreateExpressGatewayServiceCommand;2241exports.CreateServiceCommand = CreateServiceCommand;2242exports.CreateTaskSetCommand = CreateTaskSetCommand;2243exports.DaemonDeploymentRollbackMonitorsStatus = DaemonDeploymentRollbackMonitorsStatus;2244exports.DaemonDeploymentStatus = DaemonDeploymentStatus;2245exports.DaemonPropagateTags = DaemonPropagateTags;2246exports.DaemonStatus = DaemonStatus;2247exports.DaemonTaskDefinitionRevisionFilter = DaemonTaskDefinitionRevisionFilter;2248exports.DaemonTaskDefinitionStatus = DaemonTaskDefinitionStatus;2249exports.DaemonTaskDefinitionStatusFilter = DaemonTaskDefinitionStatusFilter;2250exports.DeleteAccountSettingCommand = DeleteAccountSettingCommand;2251exports.DeleteAttributesCommand = DeleteAttributesCommand;2252exports.DeleteCapacityProviderCommand = DeleteCapacityProviderCommand;2253exports.DeleteClusterCommand = DeleteClusterCommand;2254exports.DeleteDaemonCommand = DeleteDaemonCommand;2255exports.DeleteDaemonTaskDefinitionCommand = DeleteDaemonTaskDefinitionCommand;2256exports.DeleteExpressGatewayServiceCommand = DeleteExpressGatewayServiceCommand;2257exports.DeleteServiceCommand = DeleteServiceCommand;2258exports.DeleteTaskDefinitionsCommand = DeleteTaskDefinitionsCommand;2259exports.DeleteTaskSetCommand = DeleteTaskSetCommand;2260exports.DeploymentControllerType = DeploymentControllerType;2261exports.DeploymentLifecycleHookAction = DeploymentLifecycleHookAction;2262exports.DeploymentLifecycleHookStage = DeploymentLifecycleHookStage;2263exports.DeploymentLifecycleHookStatus = DeploymentLifecycleHookStatus;2264exports.DeploymentLifecycleHookTargetType = DeploymentLifecycleHookTargetType;2265exports.DeploymentRolloutState = DeploymentRolloutState;2266exports.DeploymentStrategy = DeploymentStrategy;2267exports.DeregisterContainerInstanceCommand = DeregisterContainerInstanceCommand;2268exports.DeregisterTaskDefinitionCommand = DeregisterTaskDefinitionCommand;2269exports.DescribeCapacityProvidersCommand = DescribeCapacityProvidersCommand;2270exports.DescribeClustersCommand = DescribeClustersCommand;2271exports.DescribeContainerInstancesCommand = DescribeContainerInstancesCommand;2272exports.DescribeDaemonCommand = DescribeDaemonCommand;2273exports.DescribeDaemonDeploymentsCommand = DescribeDaemonDeploymentsCommand;2274exports.DescribeDaemonRevisionsCommand = DescribeDaemonRevisionsCommand;2275exports.DescribeDaemonTaskDefinitionCommand = DescribeDaemonTaskDefinitionCommand;2276exports.DescribeExpressGatewayServiceCommand = DescribeExpressGatewayServiceCommand;2277exports.DescribeServiceDeploymentsCommand = DescribeServiceDeploymentsCommand;2278exports.DescribeServiceRevisionsCommand = DescribeServiceRevisionsCommand;2279exports.DescribeServicesCommand = DescribeServicesCommand;2280exports.DescribeTaskDefinitionCommand = DescribeTaskDefinitionCommand;2281exports.DescribeTaskSetsCommand = DescribeTaskSetsCommand;2282exports.DescribeTasksCommand = DescribeTasksCommand;2283exports.DesiredStatus = DesiredStatus;2284exports.DeviceCgroupPermission = DeviceCgroupPermission;2285exports.DiscoverPollEndpointCommand = DiscoverPollEndpointCommand;2286exports.EBSResourceType = EBSResourceType;2287exports.ECS = ECS;2288exports.ECSClient = ECSClient;2289exports.EFSAuthorizationConfigIAM = EFSAuthorizationConfigIAM;2290exports.EFSTransitEncryption = EFSTransitEncryption;2291exports.EnvironmentFileType = EnvironmentFileType;2292exports.ExecuteCommandCommand = ExecuteCommandCommand;2293exports.ExecuteCommandLogging = ExecuteCommandLogging;2294exports.ExpressGatewayServiceInclude = ExpressGatewayServiceInclude;2295exports.ExpressGatewayServiceScalingMetric = ExpressGatewayServiceScalingMetric;2296exports.ExpressGatewayServiceStatusCode = ExpressGatewayServiceStatusCode;2297exports.FirelensConfigurationType = FirelensConfigurationType;2298exports.GetTaskProtectionCommand = GetTaskProtectionCommand;2299exports.HealthStatus = HealthStatus;2300exports.InstanceGeneration = InstanceGeneration;2301exports.InstanceHealthCheckState = InstanceHealthCheckState;2302exports.InstanceHealthCheckType = InstanceHealthCheckType;2303exports.IpcMode = IpcMode;2304exports.LaunchType = LaunchType;2305exports.ListAccountSettingsCommand = ListAccountSettingsCommand;2306exports.ListAttributesCommand = ListAttributesCommand;2307exports.ListClustersCommand = ListClustersCommand;2308exports.ListContainerInstancesCommand = ListContainerInstancesCommand;2309exports.ListDaemonDeploymentsCommand = ListDaemonDeploymentsCommand;2310exports.ListDaemonTaskDefinitionsCommand = ListDaemonTaskDefinitionsCommand;2311exports.ListDaemonsCommand = ListDaemonsCommand;2312exports.ListServiceDeploymentsCommand = ListServiceDeploymentsCommand;2313exports.ListServicesByNamespaceCommand = ListServicesByNamespaceCommand;2314exports.ListServicesCommand = ListServicesCommand;2315exports.ListTagsForResourceCommand = ListTagsForResourceCommand;2316exports.ListTaskDefinitionFamiliesCommand = ListTaskDefinitionFamiliesCommand;2317exports.ListTaskDefinitionsCommand = ListTaskDefinitionsCommand;2318exports.ListTasksCommand = ListTasksCommand;2319exports.LocalStorage = LocalStorage;2320exports.LocalStorageType = LocalStorageType;2321exports.LogDriver = LogDriver;2322exports.ManagedAgentName = ManagedAgentName;2323exports.ManagedDraining = ManagedDraining;2324exports.ManagedInstancesMonitoringOptions = ManagedInstancesMonitoringOptions;2325exports.ManagedResourceStatus = ManagedResourceStatus;2326exports.ManagedScalingStatus = ManagedScalingStatus;2327exports.ManagedTerminationProtection = ManagedTerminationProtection;2328exports.NetworkMode = NetworkMode;2329exports.OSFamily = OSFamily;2330exports.PidMode = PidMode;2331exports.PlacementConstraintType = PlacementConstraintType;2332exports.PlacementStrategyType = PlacementStrategyType;2333exports.PlatformDeviceType = PlatformDeviceType;2334exports.PropagateMITags = PropagateMITags;2335exports.PropagateTags = PropagateTags;2336exports.ProxyConfigurationType = ProxyConfigurationType;2337exports.PutAccountSettingCommand = PutAccountSettingCommand;2338exports.PutAccountSettingDefaultCommand = PutAccountSettingDefaultCommand;2339exports.PutAttributesCommand = PutAttributesCommand;2340exports.PutClusterCapacityProvidersCommand = PutClusterCapacityProvidersCommand;2341exports.RegisterContainerInstanceCommand = RegisterContainerInstanceCommand;2342exports.RegisterDaemonTaskDefinitionCommand = RegisterDaemonTaskDefinitionCommand;2343exports.RegisterTaskDefinitionCommand = RegisterTaskDefinitionCommand;2344exports.ResourceManagementType = ResourceManagementType;2345exports.ResourceType = ResourceType;2346exports.RunTaskCommand = RunTaskCommand;2347exports.ScaleUnit = ScaleUnit;2348exports.SchedulingStrategy = SchedulingStrategy;2349exports.Scope = Scope;2350exports.ServiceConnectAccessLoggingFormat = ServiceConnectAccessLoggingFormat;2351exports.ServiceConnectIncludeQueryParameters = ServiceConnectIncludeQueryParameters;2352exports.ServiceDeploymentLifecycleStage = ServiceDeploymentLifecycleStage;2353exports.ServiceDeploymentRollbackMonitorsStatus = ServiceDeploymentRollbackMonitorsStatus;2354exports.ServiceDeploymentStatus = ServiceDeploymentStatus;2355exports.ServiceField = ServiceField;2356exports.SettingName = SettingName;2357exports.SettingType = SettingType;2358exports.SortOrder = SortOrder;2359exports.StabilityStatus = StabilityStatus;2360exports.StartTaskCommand = StartTaskCommand;2361exports.StopServiceDeploymentCommand = StopServiceDeploymentCommand;2362exports.StopServiceDeploymentStopType = StopServiceDeploymentStopType;2363exports.StopTaskCommand = StopTaskCommand;2364exports.SubmitAttachmentStateChangesCommand = SubmitAttachmentStateChangesCommand;2365exports.SubmitContainerStateChangeCommand = SubmitContainerStateChangeCommand;2366exports.SubmitTaskStateChangeCommand = SubmitTaskStateChangeCommand;2367exports.TagResourceCommand = TagResourceCommand;2368exports.TargetType = TargetType;2369exports.TaskDefinitionFamilyStatus = TaskDefinitionFamilyStatus;2370exports.TaskDefinitionField = TaskDefinitionField;2371exports.TaskDefinitionPlacementConstraintType = TaskDefinitionPlacementConstraintType;2372exports.TaskDefinitionStatus = TaskDefinitionStatus;2373exports.TaskField = TaskField;2374exports.TaskFilesystemType = TaskFilesystemType;2375exports.TaskSetField = TaskSetField;2376exports.TaskStopCode = TaskStopCode;2377exports.TransportProtocol = TransportProtocol;2378exports.UlimitName = UlimitName;2379exports.UntagResourceCommand = UntagResourceCommand;2380exports.UpdateCapacityProviderCommand = UpdateCapacityProviderCommand;2381exports.UpdateClusterCommand = UpdateClusterCommand;2382exports.UpdateClusterSettingsCommand = UpdateClusterSettingsCommand;2383exports.UpdateContainerAgentCommand = UpdateContainerAgentCommand;2384exports.UpdateContainerInstancesStateCommand = UpdateContainerInstancesStateCommand;2385exports.UpdateDaemonCommand = UpdateDaemonCommand;2386exports.UpdateExpressGatewayServiceCommand = UpdateExpressGatewayServiceCommand;2387exports.UpdateServiceCommand = UpdateServiceCommand;2388exports.UpdateServicePrimaryTaskSetCommand = UpdateServicePrimaryTaskSetCommand;2389exports.UpdateTaskProtectionCommand = UpdateTaskProtectionCommand;2390exports.UpdateTaskSetCommand = UpdateTaskSetCommand;2391exports.VersionConsistency = VersionConsistency;2392exports.paginateListAccountSettings = paginateListAccountSettings;2393exports.paginateListAttributes = paginateListAttributes;2394exports.paginateListClusters = paginateListClusters;2395exports.paginateListContainerInstances = paginateListContainerInstances;2396exports.paginateListServices = paginateListServices;2397exports.paginateListServicesByNamespace = paginateListServicesByNamespace;2398exports.paginateListTaskDefinitionFamilies = paginateListTaskDefinitionFamilies;2399exports.paginateListTaskDefinitions = paginateListTaskDefinitions;2400exports.paginateListTasks = paginateListTasks;2401exports.waitForDaemonActive = waitForDaemonActive;2402exports.waitForDaemonDeploymentStopped = waitForDaemonDeploymentStopped;2403exports.waitForDaemonDeploymentSuccessful = waitForDaemonDeploymentSuccessful;2404exports.waitForDaemonTaskDefinitionActive = waitForDaemonTaskDefinitionActive;2405exports.waitForDaemonTaskDefinitionDeleted = waitForDaemonTaskDefinitionDeleted;2406exports.waitForServicesInactive = waitForServicesInactive;2407exports.waitForServicesStable = waitForServicesStable;2408exports.waitForTasksRunning = waitForTasksRunning;2409exports.waitForTasksStopped = waitForTasksStopped;2410exports.waitUntilDaemonActive = waitUntilDaemonActive;2411exports.waitUntilDaemonDeploymentStopped = waitUntilDaemonDeploymentStopped;2412exports.waitUntilDaemonDeploymentSuccessful = waitUntilDaemonDeploymentSuccessful;2413exports.waitUntilDaemonTaskDefinitionActive = waitUntilDaemonTaskDefinitionActive;2414exports.waitUntilDaemonTaskDefinitionDeleted = waitUntilDaemonTaskDefinitionDeleted;2415exports.waitUntilServicesInactive = waitUntilServicesInactive;2416exports.waitUntilServicesStable = waitUntilServicesStable;2417exports.waitUntilTasksRunning = waitUntilTasksRunning;2418exports.waitUntilTasksStopped = waitUntilTasksStopped;2419Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&2420    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&2421    Object.defineProperty(exports, '__proto__', {2422        enumerable: true,2423        value: schemas_0['__proto__']2424    });2425 2426Object.keys(schemas_0).forEach(function (k) {2427    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];2428});2429Object.prototype.hasOwnProperty.call(errors, '__proto__') &&2430    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&2431    Object.defineProperty(exports, '__proto__', {2432        enumerable: true,2433        value: errors['__proto__']2434    });2435 2436Object.keys(errors).forEach(function (k) {2437    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];2438});2439