@aws-sdk/client-ecs 3.50.0 → 3.53.0

package/dist-types/ts3.4/commands/DeregisterTaskDefinitionCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { DeregisterTaskDefinitionRequest, DeregisterTaskDefinitionResponse } from "../models/models_0";
+export interface DeregisterTaskDefinitionCommandInput extends DeregisterTaskDefinitionRequest {
+}
+export interface DeregisterTaskDefinitionCommandOutput extends DeregisterTaskDefinitionResponse, __MetadataBearer {
+}
+
+export declare class DeregisterTaskDefinitionCommand extends $Command<DeregisterTaskDefinitionCommandInput, DeregisterTaskDefinitionCommandOutput, ECSClientResolvedConfig> {
+    readonly input: DeregisterTaskDefinitionCommandInput;
+    constructor(input: DeregisterTaskDefinitionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterTaskDefinitionCommandInput, DeregisterTaskDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeCapacityProvidersCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { DescribeCapacityProvidersRequest, DescribeCapacityProvidersResponse } from "../models/models_0";
+export interface DescribeCapacityProvidersCommandInput extends DescribeCapacityProvidersRequest {
+}
+export interface DescribeCapacityProvidersCommandOutput extends DescribeCapacityProvidersResponse, __MetadataBearer {
+}
+
+export declare class DescribeCapacityProvidersCommand extends $Command<DescribeCapacityProvidersCommandInput, DescribeCapacityProvidersCommandOutput, ECSClientResolvedConfig> {
+    readonly input: DescribeCapacityProvidersCommandInput;
+    constructor(input: DescribeCapacityProvidersCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCapacityProvidersCommandInput, DescribeCapacityProvidersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeClustersCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { DescribeClustersRequest, DescribeClustersResponse } from "../models/models_0";
+export interface DescribeClustersCommandInput extends DescribeClustersRequest {
+}
+export interface DescribeClustersCommandOutput extends DescribeClustersResponse, __MetadataBearer {
+}
+
+export declare class DescribeClustersCommand extends $Command<DescribeClustersCommandInput, DescribeClustersCommandOutput, ECSClientResolvedConfig> {
+    readonly input: DescribeClustersCommandInput;
+    constructor(input: DescribeClustersCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeClustersCommandInput, DescribeClustersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeContainerInstancesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { DescribeContainerInstancesRequest, DescribeContainerInstancesResponse } from "../models/models_0";
+export interface DescribeContainerInstancesCommandInput extends DescribeContainerInstancesRequest {
+}
+export interface DescribeContainerInstancesCommandOutput extends DescribeContainerInstancesResponse, __MetadataBearer {
+}
+
+export declare class DescribeContainerInstancesCommand extends $Command<DescribeContainerInstancesCommandInput, DescribeContainerInstancesCommandOutput, ECSClientResolvedConfig> {
+    readonly input: DescribeContainerInstancesCommandInput;
+    constructor(input: DescribeContainerInstancesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeContainerInstancesCommandInput, DescribeContainerInstancesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeServicesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { DescribeServicesRequest, DescribeServicesResponse } from "../models/models_0";
+export interface DescribeServicesCommandInput extends DescribeServicesRequest {
+}
+export interface DescribeServicesCommandOutput extends DescribeServicesResponse, __MetadataBearer {
+}
+
+export declare class DescribeServicesCommand extends $Command<DescribeServicesCommandInput, DescribeServicesCommandOutput, ECSClientResolvedConfig> {
+    readonly input: DescribeServicesCommandInput;
+    constructor(input: DescribeServicesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeServicesCommandInput, DescribeServicesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeTaskDefinitionCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { DescribeTaskDefinitionRequest, DescribeTaskDefinitionResponse } from "../models/models_0";
+export interface DescribeTaskDefinitionCommandInput extends DescribeTaskDefinitionRequest {
+}
+export interface DescribeTaskDefinitionCommandOutput extends DescribeTaskDefinitionResponse, __MetadataBearer {
+}
+
+export declare class DescribeTaskDefinitionCommand extends $Command<DescribeTaskDefinitionCommandInput, DescribeTaskDefinitionCommandOutput, ECSClientResolvedConfig> {
+    readonly input: DescribeTaskDefinitionCommandInput;
+    constructor(input: DescribeTaskDefinitionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTaskDefinitionCommandInput, DescribeTaskDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeTaskSetsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { DescribeTaskSetsRequest, DescribeTaskSetsResponse } from "../models/models_0";
+export interface DescribeTaskSetsCommandInput extends DescribeTaskSetsRequest {
+}
+export interface DescribeTaskSetsCommandOutput extends DescribeTaskSetsResponse, __MetadataBearer {
+}
+
+export declare class DescribeTaskSetsCommand extends $Command<DescribeTaskSetsCommandInput, DescribeTaskSetsCommandOutput, ECSClientResolvedConfig> {
+    readonly input: DescribeTaskSetsCommandInput;
+    constructor(input: DescribeTaskSetsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTaskSetsCommandInput, DescribeTaskSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeTasksCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { DescribeTasksRequest, DescribeTasksResponse } from "../models/models_0";
+export interface DescribeTasksCommandInput extends DescribeTasksRequest {
+}
+export interface DescribeTasksCommandOutput extends DescribeTasksResponse, __MetadataBearer {
+}
+
+export declare class DescribeTasksCommand extends $Command<DescribeTasksCommandInput, DescribeTasksCommandOutput, ECSClientResolvedConfig> {
+    readonly input: DescribeTasksCommandInput;
+    constructor(input: DescribeTasksCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTasksCommandInput, DescribeTasksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DiscoverPollEndpointCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { DiscoverPollEndpointRequest, DiscoverPollEndpointResponse } from "../models/models_0";
+export interface DiscoverPollEndpointCommandInput extends DiscoverPollEndpointRequest {
+}
+export interface DiscoverPollEndpointCommandOutput extends DiscoverPollEndpointResponse, __MetadataBearer {
+}
+
+export declare class DiscoverPollEndpointCommand extends $Command<DiscoverPollEndpointCommandInput, DiscoverPollEndpointCommandOutput, ECSClientResolvedConfig> {
+    readonly input: DiscoverPollEndpointCommandInput;
+    constructor(input: DiscoverPollEndpointCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DiscoverPollEndpointCommandInput, DiscoverPollEndpointCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ExecuteCommandCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { ExecuteCommandRequest, ExecuteCommandResponse } from "../models/models_0";
+export interface ExecuteCommandCommandInput extends ExecuteCommandRequest {
+}
+export interface ExecuteCommandCommandOutput extends ExecuteCommandResponse, __MetadataBearer {
+}
+
+export declare class ExecuteCommandCommand extends $Command<ExecuteCommandCommandInput, ExecuteCommandCommandOutput, ECSClientResolvedConfig> {
+    readonly input: ExecuteCommandCommandInput;
+    constructor(input: ExecuteCommandCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecuteCommandCommandInput, ExecuteCommandCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListAccountSettingsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { ListAccountSettingsRequest, ListAccountSettingsResponse } from "../models/models_0";
+export interface ListAccountSettingsCommandInput extends ListAccountSettingsRequest {
+}
+export interface ListAccountSettingsCommandOutput extends ListAccountSettingsResponse, __MetadataBearer {
+}
+
+export declare class ListAccountSettingsCommand extends $Command<ListAccountSettingsCommandInput, ListAccountSettingsCommandOutput, ECSClientResolvedConfig> {
+    readonly input: ListAccountSettingsCommandInput;
+    constructor(input: ListAccountSettingsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAccountSettingsCommandInput, ListAccountSettingsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListAttributesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { ListAttributesRequest, ListAttributesResponse } from "../models/models_0";
+export interface ListAttributesCommandInput extends ListAttributesRequest {
+}
+export interface ListAttributesCommandOutput extends ListAttributesResponse, __MetadataBearer {
+}
+
+export declare class ListAttributesCommand extends $Command<ListAttributesCommandInput, ListAttributesCommandOutput, ECSClientResolvedConfig> {
+    readonly input: ListAttributesCommandInput;
+    constructor(input: ListAttributesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAttributesCommandInput, ListAttributesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListClustersCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { ListClustersRequest, ListClustersResponse } from "../models/models_0";
+export interface ListClustersCommandInput extends ListClustersRequest {
+}
+export interface ListClustersCommandOutput extends ListClustersResponse, __MetadataBearer {
+}
+
+export declare class ListClustersCommand extends $Command<ListClustersCommandInput, ListClustersCommandOutput, ECSClientResolvedConfig> {
+    readonly input: ListClustersCommandInput;
+    constructor(input: ListClustersCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListClustersCommandInput, ListClustersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListContainerInstancesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { ListContainerInstancesRequest, ListContainerInstancesResponse } from "../models/models_0";
+export interface ListContainerInstancesCommandInput extends ListContainerInstancesRequest {
+}
+export interface ListContainerInstancesCommandOutput extends ListContainerInstancesResponse, __MetadataBearer {
+}
+
+export declare class ListContainerInstancesCommand extends $Command<ListContainerInstancesCommandInput, ListContainerInstancesCommandOutput, ECSClientResolvedConfig> {
+    readonly input: ListContainerInstancesCommandInput;
+    constructor(input: ListContainerInstancesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListContainerInstancesCommandInput, ListContainerInstancesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListServicesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { ListServicesRequest, ListServicesResponse } from "../models/models_0";
+export interface ListServicesCommandInput extends ListServicesRequest {
+}
+export interface ListServicesCommandOutput extends ListServicesResponse, __MetadataBearer {
+}
+
+export declare class ListServicesCommand extends $Command<ListServicesCommandInput, ListServicesCommandOutput, ECSClientResolvedConfig> {
+    readonly input: ListServicesCommandInput;
+    constructor(input: ListServicesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListServicesCommandInput, ListServicesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, ECSClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListTaskDefinitionFamiliesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { ListTaskDefinitionFamiliesRequest, ListTaskDefinitionFamiliesResponse } from "../models/models_0";
+export interface ListTaskDefinitionFamiliesCommandInput extends ListTaskDefinitionFamiliesRequest {
+}
+export interface ListTaskDefinitionFamiliesCommandOutput extends ListTaskDefinitionFamiliesResponse, __MetadataBearer {
+}
+
+export declare class ListTaskDefinitionFamiliesCommand extends $Command<ListTaskDefinitionFamiliesCommandInput, ListTaskDefinitionFamiliesCommandOutput, ECSClientResolvedConfig> {
+    readonly input: ListTaskDefinitionFamiliesCommandInput;
+    constructor(input: ListTaskDefinitionFamiliesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTaskDefinitionFamiliesCommandInput, ListTaskDefinitionFamiliesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListTaskDefinitionsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { ListTaskDefinitionsRequest, ListTaskDefinitionsResponse } from "../models/models_0";
+export interface ListTaskDefinitionsCommandInput extends ListTaskDefinitionsRequest {
+}
+export interface ListTaskDefinitionsCommandOutput extends ListTaskDefinitionsResponse, __MetadataBearer {
+}
+
+export declare class ListTaskDefinitionsCommand extends $Command<ListTaskDefinitionsCommandInput, ListTaskDefinitionsCommandOutput, ECSClientResolvedConfig> {
+    readonly input: ListTaskDefinitionsCommandInput;
+    constructor(input: ListTaskDefinitionsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTaskDefinitionsCommandInput, ListTaskDefinitionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListTasksCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { ListTasksRequest, ListTasksResponse } from "../models/models_0";
+export interface ListTasksCommandInput extends ListTasksRequest {
+}
+export interface ListTasksCommandOutput extends ListTasksResponse, __MetadataBearer {
+}
+
+export declare class ListTasksCommand extends $Command<ListTasksCommandInput, ListTasksCommandOutput, ECSClientResolvedConfig> {
+    readonly input: ListTasksCommandInput;
+    constructor(input: ListTasksCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTasksCommandInput, ListTasksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutAccountSettingCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { PutAccountSettingRequest, PutAccountSettingResponse } from "../models/models_0";
+export interface PutAccountSettingCommandInput extends PutAccountSettingRequest {
+}
+export interface PutAccountSettingCommandOutput extends PutAccountSettingResponse, __MetadataBearer {
+}
+
+export declare class PutAccountSettingCommand extends $Command<PutAccountSettingCommandInput, PutAccountSettingCommandOutput, ECSClientResolvedConfig> {
+    readonly input: PutAccountSettingCommandInput;
+    constructor(input: PutAccountSettingCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAccountSettingCommandInput, PutAccountSettingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutAccountSettingDefaultCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { PutAccountSettingDefaultRequest, PutAccountSettingDefaultResponse } from "../models/models_0";
+export interface PutAccountSettingDefaultCommandInput extends PutAccountSettingDefaultRequest {
+}
+export interface PutAccountSettingDefaultCommandOutput extends PutAccountSettingDefaultResponse, __MetadataBearer {
+}
+
+export declare class PutAccountSettingDefaultCommand extends $Command<PutAccountSettingDefaultCommandInput, PutAccountSettingDefaultCommandOutput, ECSClientResolvedConfig> {
+    readonly input: PutAccountSettingDefaultCommandInput;
+    constructor(input: PutAccountSettingDefaultCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAccountSettingDefaultCommandInput, PutAccountSettingDefaultCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutAttributesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { PutAttributesRequest, PutAttributesResponse } from "../models/models_0";
+export interface PutAttributesCommandInput extends PutAttributesRequest {
+}
+export interface PutAttributesCommandOutput extends PutAttributesResponse, __MetadataBearer {
+}
+
+export declare class PutAttributesCommand extends $Command<PutAttributesCommandInput, PutAttributesCommandOutput, ECSClientResolvedConfig> {
+    readonly input: PutAttributesCommandInput;
+    constructor(input: PutAttributesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAttributesCommandInput, PutAttributesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutClusterCapacityProvidersCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { PutClusterCapacityProvidersRequest, PutClusterCapacityProvidersResponse } from "../models/models_0";
+export interface PutClusterCapacityProvidersCommandInput extends PutClusterCapacityProvidersRequest {
+}
+export interface PutClusterCapacityProvidersCommandOutput extends PutClusterCapacityProvidersResponse, __MetadataBearer {
+}
+
+export declare class PutClusterCapacityProvidersCommand extends $Command<PutClusterCapacityProvidersCommandInput, PutClusterCapacityProvidersCommandOutput, ECSClientResolvedConfig> {
+    readonly input: PutClusterCapacityProvidersCommandInput;
+    constructor(input: PutClusterCapacityProvidersCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutClusterCapacityProvidersCommandInput, PutClusterCapacityProvidersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/RegisterContainerInstanceCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { RegisterContainerInstanceRequest, RegisterContainerInstanceResponse } from "../models/models_0";
+export interface RegisterContainerInstanceCommandInput extends RegisterContainerInstanceRequest {
+}
+export interface RegisterContainerInstanceCommandOutput extends RegisterContainerInstanceResponse, __MetadataBearer {
+}
+
+export declare class RegisterContainerInstanceCommand extends $Command<RegisterContainerInstanceCommandInput, RegisterContainerInstanceCommandOutput, ECSClientResolvedConfig> {
+    readonly input: RegisterContainerInstanceCommandInput;
+    constructor(input: RegisterContainerInstanceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterContainerInstanceCommandInput, RegisterContainerInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/RegisterTaskDefinitionCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { RegisterTaskDefinitionRequest, RegisterTaskDefinitionResponse } from "../models/models_0";
+export interface RegisterTaskDefinitionCommandInput extends RegisterTaskDefinitionRequest {
+}
+export interface RegisterTaskDefinitionCommandOutput extends RegisterTaskDefinitionResponse, __MetadataBearer {
+}
+
+export declare class RegisterTaskDefinitionCommand extends $Command<RegisterTaskDefinitionCommandInput, RegisterTaskDefinitionCommandOutput, ECSClientResolvedConfig> {
+    readonly input: RegisterTaskDefinitionCommandInput;
+    constructor(input: RegisterTaskDefinitionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterTaskDefinitionCommandInput, RegisterTaskDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/RunTaskCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { RunTaskRequest, RunTaskResponse } from "../models/models_0";
+export interface RunTaskCommandInput extends RunTaskRequest {
+}
+export interface RunTaskCommandOutput extends RunTaskResponse, __MetadataBearer {
+}
+
+export declare class RunTaskCommand extends $Command<RunTaskCommandInput, RunTaskCommandOutput, ECSClientResolvedConfig> {
+    readonly input: RunTaskCommandInput;
+    constructor(input: RunTaskCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RunTaskCommandInput, RunTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/StartTaskCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { StartTaskRequest, StartTaskResponse } from "../models/models_0";
+export interface StartTaskCommandInput extends StartTaskRequest {
+}
+export interface StartTaskCommandOutput extends StartTaskResponse, __MetadataBearer {
+}
+
+export declare class StartTaskCommand extends $Command<StartTaskCommandInput, StartTaskCommandOutput, ECSClientResolvedConfig> {
+    readonly input: StartTaskCommandInput;
+    constructor(input: StartTaskCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartTaskCommandInput, StartTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/StopTaskCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { StopTaskRequest, StopTaskResponse } from "../models/models_0";
+export interface StopTaskCommandInput extends StopTaskRequest {
+}
+export interface StopTaskCommandOutput extends StopTaskResponse, __MetadataBearer {
+}
+
+export declare class StopTaskCommand extends $Command<StopTaskCommandInput, StopTaskCommandOutput, ECSClientResolvedConfig> {
+    readonly input: StopTaskCommandInput;
+    constructor(input: StopTaskCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopTaskCommandInput, StopTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/SubmitAttachmentStateChangesCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { SubmitAttachmentStateChangesRequest, SubmitAttachmentStateChangesResponse } from "../models/models_0";
+export interface SubmitAttachmentStateChangesCommandInput extends SubmitAttachmentStateChangesRequest {
+}
+export interface SubmitAttachmentStateChangesCommandOutput extends SubmitAttachmentStateChangesResponse, __MetadataBearer {
+}
+
+export declare class SubmitAttachmentStateChangesCommand extends $Command<SubmitAttachmentStateChangesCommandInput, SubmitAttachmentStateChangesCommandOutput, ECSClientResolvedConfig> {
+    readonly input: SubmitAttachmentStateChangesCommandInput;
+    constructor(input: SubmitAttachmentStateChangesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SubmitAttachmentStateChangesCommandInput, SubmitAttachmentStateChangesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/SubmitContainerStateChangeCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { SubmitContainerStateChangeRequest, SubmitContainerStateChangeResponse } from "../models/models_0";
+export interface SubmitContainerStateChangeCommandInput extends SubmitContainerStateChangeRequest {
+}
+export interface SubmitContainerStateChangeCommandOutput extends SubmitContainerStateChangeResponse, __MetadataBearer {
+}
+
+export declare class SubmitContainerStateChangeCommand extends $Command<SubmitContainerStateChangeCommandInput, SubmitContainerStateChangeCommandOutput, ECSClientResolvedConfig> {
+    readonly input: SubmitContainerStateChangeCommandInput;
+    constructor(input: SubmitContainerStateChangeCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SubmitContainerStateChangeCommandInput, SubmitContainerStateChangeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/SubmitTaskStateChangeCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { SubmitTaskStateChangeRequest, SubmitTaskStateChangeResponse } from "../models/models_0";
+export interface SubmitTaskStateChangeCommandInput extends SubmitTaskStateChangeRequest {
+}
+export interface SubmitTaskStateChangeCommandOutput extends SubmitTaskStateChangeResponse, __MetadataBearer {
+}
+
+export declare class SubmitTaskStateChangeCommand extends $Command<SubmitTaskStateChangeCommandInput, SubmitTaskStateChangeCommandOutput, ECSClientResolvedConfig> {
+    readonly input: SubmitTaskStateChangeCommandInput;
+    constructor(input: SubmitTaskStateChangeCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SubmitTaskStateChangeCommandInput, SubmitTaskStateChangeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/TagResourceCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
+}
+
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ECSClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UntagResourceCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ECSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ECSClient";
+import { UntagResourceRequest, UntagResourceResponse } from "../models/models_0";
+export interface UntagResourceCommandInput extends UntagResourceRequest {
+}
+export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
+}
+
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, ECSClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    constructor(input: UntagResourceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}