@aws-sdk/client-ecs 3.478.0 → 3.481.0

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -20,19 +14,16 @@ export interface PutAttributesCommandInput extends PutAttributesRequest {}
 export interface PutAttributesCommandOutput
   extends PutAttributesResponse,
     __MetadataBearer {}
-export declare class PutAttributesCommand extends $Command<
-  PutAttributesCommandInput,
-  PutAttributesCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: PutAttributesCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: PutAttributesCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutAttributesCommandInput, PutAttributesCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const PutAttributesCommand_base: {
+  new (
+    input: PutAttributesCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    PutAttributesCommandInput,
+    PutAttributesCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class PutAttributesCommand extends PutAttributesCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -21,22 +15,16 @@ export interface PutClusterCapacityProvidersCommandInput
 export interface PutClusterCapacityProvidersCommandOutput
   extends PutClusterCapacityProvidersResponse,
     __MetadataBearer {}
-export declare class PutClusterCapacityProvidersCommand extends $Command<
-  PutClusterCapacityProvidersCommandInput,
-  PutClusterCapacityProvidersCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: PutClusterCapacityProvidersCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: PutClusterCapacityProvidersCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const PutClusterCapacityProvidersCommand_base: {
+  new (
+    input: PutClusterCapacityProvidersCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     PutClusterCapacityProvidersCommandInput,
-    PutClusterCapacityProvidersCommandOutput
+    PutClusterCapacityProvidersCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class PutClusterCapacityProvidersCommand extends PutClusterCapacityProvidersCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -21,22 +15,16 @@ export interface RegisterContainerInstanceCommandInput
 export interface RegisterContainerInstanceCommandOutput
   extends RegisterContainerInstanceResponse,
     __MetadataBearer {}
-export declare class RegisterContainerInstanceCommand extends $Command<
-  RegisterContainerInstanceCommandInput,
-  RegisterContainerInstanceCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: RegisterContainerInstanceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: RegisterContainerInstanceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const RegisterContainerInstanceCommand_base: {
+  new (
+    input: RegisterContainerInstanceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     RegisterContainerInstanceCommandInput,
-    RegisterContainerInstanceCommandOutput
+    RegisterContainerInstanceCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class RegisterContainerInstanceCommand extends RegisterContainerInstanceCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -21,22 +15,16 @@ export interface RegisterTaskDefinitionCommandInput
 export interface RegisterTaskDefinitionCommandOutput
   extends RegisterTaskDefinitionResponse,
     __MetadataBearer {}
-export declare class RegisterTaskDefinitionCommand extends $Command<
-  RegisterTaskDefinitionCommandInput,
-  RegisterTaskDefinitionCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: RegisterTaskDefinitionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: RegisterTaskDefinitionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const RegisterTaskDefinitionCommand_base: {
+  new (
+    input: RegisterTaskDefinitionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     RegisterTaskDefinitionCommandInput,
-    RegisterTaskDefinitionCommandOutput
+    RegisterTaskDefinitionCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class RegisterTaskDefinitionCommand extends RegisterTaskDefinitionCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -17,19 +11,14 @@ export interface RunTaskCommandInput extends RunTaskRequest {}
 export interface RunTaskCommandOutput
   extends RunTaskResponse,
     __MetadataBearer {}
-export declare class RunTaskCommand extends $Command<
-  RunTaskCommandInput,
-  RunTaskCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: RunTaskCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: RunTaskCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<RunTaskCommandInput, RunTaskCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const RunTaskCommand_base: {
+  new (input: RunTaskCommandInput): import("@smithy/smithy-client").CommandImpl<
+    RunTaskCommandInput,
+    RunTaskCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class RunTaskCommand extends RunTaskCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface StartTaskCommandInput extends StartTaskRequest {}
 export interface StartTaskCommandOutput
   extends StartTaskResponse,
     __MetadataBearer {}
-export declare class StartTaskCommand extends $Command<
-  StartTaskCommandInput,
-  StartTaskCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: StartTaskCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: StartTaskCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<StartTaskCommandInput, StartTaskCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const StartTaskCommand_base: {
+  new (
+    input: StartTaskCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    StartTaskCommandInput,
+    StartTaskCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StartTaskCommand extends StartTaskCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface StopTaskCommandInput extends StopTaskRequest {}
 export interface StopTaskCommandOutput
   extends StopTaskResponse,
     __MetadataBearer {}
-export declare class StopTaskCommand extends $Command<
-  StopTaskCommandInput,
-  StopTaskCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: StopTaskCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: StopTaskCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<StopTaskCommandInput, StopTaskCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const StopTaskCommand_base: {
+  new (
+    input: StopTaskCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    StopTaskCommandInput,
+    StopTaskCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StopTaskCommand extends StopTaskCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -21,22 +15,16 @@ export interface SubmitAttachmentStateChangesCommandInput
 export interface SubmitAttachmentStateChangesCommandOutput
   extends SubmitAttachmentStateChangesResponse,
     __MetadataBearer {}
-export declare class SubmitAttachmentStateChangesCommand extends $Command<
-  SubmitAttachmentStateChangesCommandInput,
-  SubmitAttachmentStateChangesCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: SubmitAttachmentStateChangesCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: SubmitAttachmentStateChangesCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const SubmitAttachmentStateChangesCommand_base: {
+  new (
+    input: SubmitAttachmentStateChangesCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     SubmitAttachmentStateChangesCommandInput,
-    SubmitAttachmentStateChangesCommandOutput
+    SubmitAttachmentStateChangesCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class SubmitAttachmentStateChangesCommand extends SubmitAttachmentStateChangesCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -21,22 +15,16 @@ export interface SubmitContainerStateChangeCommandInput
 export interface SubmitContainerStateChangeCommandOutput
   extends SubmitContainerStateChangeResponse,
     __MetadataBearer {}
-export declare class SubmitContainerStateChangeCommand extends $Command<
-  SubmitContainerStateChangeCommandInput,
-  SubmitContainerStateChangeCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: SubmitContainerStateChangeCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: SubmitContainerStateChangeCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const SubmitContainerStateChangeCommand_base: {
+  new (
+    input: SubmitContainerStateChangeCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     SubmitContainerStateChangeCommandInput,
-    SubmitContainerStateChangeCommandOutput
+    SubmitContainerStateChangeCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class SubmitContainerStateChangeCommand extends SubmitContainerStateChangeCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -21,22 +15,16 @@ export interface SubmitTaskStateChangeCommandInput
 export interface SubmitTaskStateChangeCommandOutput
   extends SubmitTaskStateChangeResponse,
     __MetadataBearer {}
-export declare class SubmitTaskStateChangeCommand extends $Command<
-  SubmitTaskStateChangeCommandInput,
-  SubmitTaskStateChangeCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: SubmitTaskStateChangeCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: SubmitTaskStateChangeCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const SubmitTaskStateChangeCommand_base: {
+  new (
+    input: SubmitTaskStateChangeCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     SubmitTaskStateChangeCommandInput,
-    SubmitTaskStateChangeCommandOutput
+    SubmitTaskStateChangeCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class SubmitTaskStateChangeCommand extends SubmitTaskStateChangeCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface TagResourceCommandInput extends TagResourceRequest {}
 export interface TagResourceCommandOutput
   extends TagResourceResponse,
     __MetadataBearer {}
-export declare class TagResourceCommand extends $Command<
-  TagResourceCommandInput,
-  TagResourceCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: TagResourceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: TagResourceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const TagResourceCommand_base: {
+  new (
+    input: TagResourceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    TagResourceCommandInput,
+    TagResourceCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class TagResourceCommand extends TagResourceCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -20,19 +14,16 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {}
 export interface UntagResourceCommandOutput
   extends UntagResourceResponse,
     __MetadataBearer {}
-export declare class UntagResourceCommand extends $Command<
-  UntagResourceCommandInput,
-  UntagResourceCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: UntagResourceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: UntagResourceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const UntagResourceCommand_base: {
+  new (
+    input: UntagResourceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    UntagResourceCommandInput,
+    UntagResourceCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class UntagResourceCommand extends UntagResourceCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -21,22 +15,16 @@ export interface UpdateCapacityProviderCommandInput
 export interface UpdateCapacityProviderCommandOutput
   extends UpdateCapacityProviderResponse,
     __MetadataBearer {}
-export declare class UpdateCapacityProviderCommand extends $Command<
-  UpdateCapacityProviderCommandInput,
-  UpdateCapacityProviderCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: UpdateCapacityProviderCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: UpdateCapacityProviderCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const UpdateCapacityProviderCommand_base: {
+  new (
+    input: UpdateCapacityProviderCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     UpdateCapacityProviderCommandInput,
-    UpdateCapacityProviderCommandOutput
+    UpdateCapacityProviderCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class UpdateCapacityProviderCommand extends UpdateCapacityProviderCommand_base {}

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

@@ -1,11 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import {
   ECSClientResolvedConfig,
   ServiceInputTypes,
@@ -20,19 +14,16 @@ export interface UpdateClusterCommandInput extends UpdateClusterRequest {}
 export interface UpdateClusterCommandOutput
   extends UpdateClusterResponse,
     __MetadataBearer {}
-export declare class UpdateClusterCommand extends $Command<
-  UpdateClusterCommandInput,
-  UpdateClusterCommandOutput,
-  ECSClientResolvedConfig
-> {
-  readonly input: UpdateClusterCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: UpdateClusterCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ECSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<UpdateClusterCommandInput, UpdateClusterCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const UpdateClusterCommand_base: {
+  new (
+    input: UpdateClusterCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    UpdateClusterCommandInput,
+    UpdateClusterCommandOutput,
+    ECSClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class UpdateClusterCommand extends UpdateClusterCommand_base {}