@aws-sdk/client-ecs 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,3180 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { ECSServiceException as __BaseException } from "./ECSServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+export declare enum AgentUpdateStatus {
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    STAGED = "STAGED",
+    STAGING = "STAGING",
+    UPDATED = "UPDATED",
+    UPDATING = "UPDATING"
+}
+
+export declare class ClientException extends __BaseException {
+    readonly name: "ClientException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClientException, __BaseException>);
+}
+export declare enum ManagedScalingStatus {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface ManagedScaling {
+    
+    status?: ManagedScalingStatus | string;
+    
+    targetCapacity?: number;
+    
+    minimumScalingStepSize?: number;
+    
+    maximumScalingStepSize?: number;
+    
+    instanceWarmupPeriod?: number;
+}
+export declare namespace ManagedScaling {
+    
+    const filterSensitiveLog: (obj: ManagedScaling) => any;
+}
+export declare enum ManagedTerminationProtection {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface AutoScalingGroupProvider {
+    
+    autoScalingGroupArn: string | undefined;
+    
+    managedScaling?: ManagedScaling;
+    
+    managedTerminationProtection?: ManagedTerminationProtection | string;
+}
+export declare namespace AutoScalingGroupProvider {
+    
+    const filterSensitiveLog: (obj: AutoScalingGroupProvider) => any;
+}
+
+export interface Tag {
+    
+    key?: string;
+    
+    value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateCapacityProviderRequest {
+    
+    name: string | undefined;
+    
+    autoScalingGroupProvider: AutoScalingGroupProvider | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateCapacityProviderRequest {
+    
+    const filterSensitiveLog: (obj: CreateCapacityProviderRequest) => any;
+}
+export declare enum CapacityProviderStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+export declare enum CapacityProviderUpdateStatus {
+    DELETE_COMPLETE = "DELETE_COMPLETE",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    UPDATE_COMPLETE = "UPDATE_COMPLETE",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATE_IN_PROGRESS = "UPDATE_IN_PROGRESS"
+}
+
+export interface CapacityProvider {
+    
+    capacityProviderArn?: string;
+    
+    name?: string;
+    
+    status?: CapacityProviderStatus | string;
+    
+    autoScalingGroupProvider?: AutoScalingGroupProvider;
+    
+    updateStatus?: CapacityProviderUpdateStatus | string;
+    
+    updateStatusReason?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace CapacityProvider {
+    
+    const filterSensitiveLog: (obj: CapacityProvider) => any;
+}
+export interface CreateCapacityProviderResponse {
+    
+    capacityProvider?: CapacityProvider;
+}
+export declare namespace CreateCapacityProviderResponse {
+    
+    const filterSensitiveLog: (obj: CreateCapacityProviderResponse) => any;
+}
+
+export declare class InvalidParameterException extends __BaseException {
+    readonly name: "InvalidParameterException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterException, __BaseException>);
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+
+export declare class ServerException extends __BaseException {
+    readonly name: "ServerException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<ServerException, __BaseException>);
+}
+
+export declare class UpdateInProgressException extends __BaseException {
+    readonly name: "UpdateInProgressException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UpdateInProgressException, __BaseException>);
+}
+
+export interface ExecuteCommandLogConfiguration {
+    
+    cloudWatchLogGroupName?: string;
+    
+    cloudWatchEncryptionEnabled?: boolean;
+    
+    s3BucketName?: string;
+    
+    s3EncryptionEnabled?: boolean;
+    
+    s3KeyPrefix?: string;
+}
+export declare namespace ExecuteCommandLogConfiguration {
+    
+    const filterSensitiveLog: (obj: ExecuteCommandLogConfiguration) => any;
+}
+export declare enum ExecuteCommandLogging {
+    DEFAULT = "DEFAULT",
+    NONE = "NONE",
+    OVERRIDE = "OVERRIDE"
+}
+
+export interface ExecuteCommandConfiguration {
+    
+    kmsKeyId?: string;
+    
+    logging?: ExecuteCommandLogging | string;
+    
+    logConfiguration?: ExecuteCommandLogConfiguration;
+}
+export declare namespace ExecuteCommandConfiguration {
+    
+    const filterSensitiveLog: (obj: ExecuteCommandConfiguration) => any;
+}
+
+export interface ClusterConfiguration {
+    
+    executeCommandConfiguration?: ExecuteCommandConfiguration;
+}
+export declare namespace ClusterConfiguration {
+    
+    const filterSensitiveLog: (obj: ClusterConfiguration) => any;
+}
+
+export interface CapacityProviderStrategyItem {
+    
+    capacityProvider: string | undefined;
+    
+    weight?: number;
+    
+    base?: number;
+}
+export declare namespace CapacityProviderStrategyItem {
+    
+    const filterSensitiveLog: (obj: CapacityProviderStrategyItem) => any;
+}
+export declare enum ClusterSettingName {
+    CONTAINER_INSIGHTS = "containerInsights"
+}
+
+export interface ClusterSetting {
+    
+    name?: ClusterSettingName | string;
+    
+    value?: string;
+}
+export declare namespace ClusterSetting {
+    
+    const filterSensitiveLog: (obj: ClusterSetting) => any;
+}
+export interface CreateClusterRequest {
+    
+    clusterName?: string;
+    
+    tags?: Tag[];
+    
+    settings?: ClusterSetting[];
+    
+    configuration?: ClusterConfiguration;
+    
+    capacityProviders?: string[];
+    
+    defaultCapacityProviderStrategy?: CapacityProviderStrategyItem[];
+}
+export declare namespace CreateClusterRequest {
+    
+    const filterSensitiveLog: (obj: CreateClusterRequest) => any;
+}
+
+export interface KeyValuePair {
+    
+    name?: string;
+    
+    value?: string;
+}
+export declare namespace KeyValuePair {
+    
+    const filterSensitiveLog: (obj: KeyValuePair) => any;
+}
+
+export interface Attachment {
+    
+    id?: string;
+    
+    type?: string;
+    
+    status?: string;
+    
+    details?: KeyValuePair[];
+}
+export declare namespace Attachment {
+    
+    const filterSensitiveLog: (obj: Attachment) => any;
+}
+
+export interface Cluster {
+    
+    clusterArn?: string;
+    
+    clusterName?: string;
+    
+    configuration?: ClusterConfiguration;
+    
+    status?: string;
+    
+    registeredContainerInstancesCount?: number;
+    
+    runningTasksCount?: number;
+    
+    pendingTasksCount?: number;
+    
+    activeServicesCount?: number;
+    
+    statistics?: KeyValuePair[];
+    
+    tags?: Tag[];
+    
+    settings?: ClusterSetting[];
+    
+    capacityProviders?: string[];
+    
+    defaultCapacityProviderStrategy?: CapacityProviderStrategyItem[];
+    
+    attachments?: Attachment[];
+    
+    attachmentsStatus?: string;
+}
+export declare namespace Cluster {
+    
+    const filterSensitiveLog: (obj: Cluster) => any;
+}
+export interface CreateClusterResponse {
+    
+    cluster?: Cluster;
+}
+export declare namespace CreateClusterResponse {
+    
+    const filterSensitiveLog: (obj: CreateClusterResponse) => any;
+}
+
+export declare class ClusterNotFoundException extends __BaseException {
+    readonly name: "ClusterNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterNotFoundException, __BaseException>);
+}
+
+export interface DeploymentCircuitBreaker {
+    
+    enable: boolean | undefined;
+    
+    rollback: boolean | undefined;
+}
+export declare namespace DeploymentCircuitBreaker {
+    
+    const filterSensitiveLog: (obj: DeploymentCircuitBreaker) => any;
+}
+
+export interface DeploymentConfiguration {
+    
+    deploymentCircuitBreaker?: DeploymentCircuitBreaker;
+    
+    maximumPercent?: number;
+    
+    minimumHealthyPercent?: number;
+}
+export declare namespace DeploymentConfiguration {
+    
+    const filterSensitiveLog: (obj: DeploymentConfiguration) => any;
+}
+export declare enum DeploymentControllerType {
+    CODE_DEPLOY = "CODE_DEPLOY",
+    ECS = "ECS",
+    EXTERNAL = "EXTERNAL"
+}
+
+export interface DeploymentController {
+    
+    type: DeploymentControllerType | string | undefined;
+}
+export declare namespace DeploymentController {
+    
+    const filterSensitiveLog: (obj: DeploymentController) => any;
+}
+export declare enum LaunchType {
+    EC2 = "EC2",
+    EXTERNAL = "EXTERNAL",
+    FARGATE = "FARGATE"
+}
+
+export interface LoadBalancer {
+    
+    targetGroupArn?: string;
+    
+    loadBalancerName?: string;
+    
+    containerName?: string;
+    
+    containerPort?: number;
+}
+export declare namespace LoadBalancer {
+    
+    const filterSensitiveLog: (obj: LoadBalancer) => any;
+}
+export declare enum AssignPublicIp {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface AwsVpcConfiguration {
+    
+    subnets: string[] | undefined;
+    
+    securityGroups?: string[];
+    
+    assignPublicIp?: AssignPublicIp | string;
+}
+export declare namespace AwsVpcConfiguration {
+    
+    const filterSensitiveLog: (obj: AwsVpcConfiguration) => any;
+}
+
+export interface NetworkConfiguration {
+    
+    awsvpcConfiguration?: AwsVpcConfiguration;
+}
+export declare namespace NetworkConfiguration {
+    
+    const filterSensitiveLog: (obj: NetworkConfiguration) => any;
+}
+export declare enum PlacementConstraintType {
+    DISTINCT_INSTANCE = "distinctInstance",
+    MEMBER_OF = "memberOf"
+}
+
+export interface PlacementConstraint {
+    
+    type?: PlacementConstraintType | string;
+    
+    expression?: string;
+}
+export declare namespace PlacementConstraint {
+    
+    const filterSensitiveLog: (obj: PlacementConstraint) => any;
+}
+export declare enum PlacementStrategyType {
+    BINPACK = "binpack",
+    RANDOM = "random",
+    SPREAD = "spread"
+}
+
+export interface PlacementStrategy {
+    
+    type?: PlacementStrategyType | string;
+    
+    field?: string;
+}
+export declare namespace PlacementStrategy {
+    
+    const filterSensitiveLog: (obj: PlacementStrategy) => any;
+}
+export declare enum PropagateTags {
+    SERVICE = "SERVICE",
+    TASK_DEFINITION = "TASK_DEFINITION"
+}
+export declare enum SchedulingStrategy {
+    DAEMON = "DAEMON",
+    REPLICA = "REPLICA"
+}
+
+export interface ServiceRegistry {
+    
+    registryArn?: string;
+    
+    port?: number;
+    
+    containerName?: string;
+    
+    containerPort?: number;
+}
+export declare namespace ServiceRegistry {
+    
+    const filterSensitiveLog: (obj: ServiceRegistry) => any;
+}
+export interface CreateServiceRequest {
+    
+    cluster?: string;
+    
+    serviceName: string | undefined;
+    
+    taskDefinition?: string;
+    
+    loadBalancers?: LoadBalancer[];
+    
+    serviceRegistries?: ServiceRegistry[];
+    
+    desiredCount?: number;
+    
+    clientToken?: string;
+    
+    launchType?: LaunchType | string;
+    
+    capacityProviderStrategy?: CapacityProviderStrategyItem[];
+    
+    platformVersion?: string;
+    
+    role?: string;
+    
+    deploymentConfiguration?: DeploymentConfiguration;
+    
+    placementConstraints?: PlacementConstraint[];
+    
+    placementStrategy?: PlacementStrategy[];
+    
+    networkConfiguration?: NetworkConfiguration;
+    
+    healthCheckGracePeriodSeconds?: number;
+    
+    schedulingStrategy?: SchedulingStrategy | string;
+    
+    deploymentController?: DeploymentController;
+    
+    tags?: Tag[];
+    
+    enableECSManagedTags?: boolean;
+    
+    propagateTags?: PropagateTags | string;
+    
+    enableExecuteCommand?: boolean;
+}
+export declare namespace CreateServiceRequest {
+    
+    const filterSensitiveLog: (obj: CreateServiceRequest) => any;
+}
+export declare enum DeploymentRolloutState {
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS"
+}
+
+export interface Deployment {
+    
+    id?: string;
+    
+    status?: string;
+    
+    taskDefinition?: string;
+    
+    desiredCount?: number;
+    
+    pendingCount?: number;
+    
+    runningCount?: number;
+    
+    failedTasks?: number;
+    
+    createdAt?: Date;
+    
+    updatedAt?: Date;
+    
+    capacityProviderStrategy?: CapacityProviderStrategyItem[];
+    
+    launchType?: LaunchType | string;
+    
+    platformVersion?: string;
+    
+    platformFamily?: string;
+    
+    networkConfiguration?: NetworkConfiguration;
+    
+    rolloutState?: DeploymentRolloutState | string;
+    
+    rolloutStateReason?: string;
+}
+export declare namespace Deployment {
+    
+    const filterSensitiveLog: (obj: Deployment) => any;
+}
+
+export interface ServiceEvent {
+    
+    id?: string;
+    
+    createdAt?: Date;
+    
+    message?: string;
+}
+export declare namespace ServiceEvent {
+    
+    const filterSensitiveLog: (obj: ServiceEvent) => any;
+}
+export declare enum ScaleUnit {
+    PERCENT = "PERCENT"
+}
+
+export interface Scale {
+    
+    value?: number;
+    
+    unit?: ScaleUnit | string;
+}
+export declare namespace Scale {
+    
+    const filterSensitiveLog: (obj: Scale) => any;
+}
+export declare enum StabilityStatus {
+    STABILIZING = "STABILIZING",
+    STEADY_STATE = "STEADY_STATE"
+}
+
+export interface TaskSet {
+    
+    id?: string;
+    
+    taskSetArn?: string;
+    
+    serviceArn?: string;
+    
+    clusterArn?: string;
+    
+    startedBy?: string;
+    
+    externalId?: string;
+    
+    status?: string;
+    
+    taskDefinition?: string;
+    
+    computedDesiredCount?: number;
+    
+    pendingCount?: number;
+    
+    runningCount?: number;
+    
+    createdAt?: Date;
+    
+    updatedAt?: Date;
+    
+    launchType?: LaunchType | string;
+    
+    capacityProviderStrategy?: CapacityProviderStrategyItem[];
+    
+    platformVersion?: string;
+    
+    platformFamily?: string;
+    
+    networkConfiguration?: NetworkConfiguration;
+    
+    loadBalancers?: LoadBalancer[];
+    
+    serviceRegistries?: ServiceRegistry[];
+    
+    scale?: Scale;
+    
+    stabilityStatus?: StabilityStatus | string;
+    
+    stabilityStatusAt?: Date;
+    
+    tags?: Tag[];
+}
+export declare namespace TaskSet {
+    
+    const filterSensitiveLog: (obj: TaskSet) => any;
+}
+
+export interface Service {
+    
+    serviceArn?: string;
+    
+    serviceName?: string;
+    
+    clusterArn?: string;
+    
+    loadBalancers?: LoadBalancer[];
+    
+    serviceRegistries?: ServiceRegistry[];
+    
+    status?: string;
+    
+    desiredCount?: number;
+    
+    runningCount?: number;
+    
+    pendingCount?: number;
+    
+    launchType?: LaunchType | string;
+    
+    capacityProviderStrategy?: CapacityProviderStrategyItem[];
+    
+    platformVersion?: string;
+    
+    platformFamily?: string;
+    
+    taskDefinition?: string;
+    
+    deploymentConfiguration?: DeploymentConfiguration;
+    
+    taskSets?: TaskSet[];
+    
+    deployments?: Deployment[];
+    
+    roleArn?: string;
+    
+    events?: ServiceEvent[];
+    
+    createdAt?: Date;
+    
+    placementConstraints?: PlacementConstraint[];
+    
+    placementStrategy?: PlacementStrategy[];
+    
+    networkConfiguration?: NetworkConfiguration;
+    
+    healthCheckGracePeriodSeconds?: number;
+    
+    schedulingStrategy?: SchedulingStrategy | string;
+    
+    deploymentController?: DeploymentController;
+    
+    tags?: Tag[];
+    
+    createdBy?: string;
+    
+    enableECSManagedTags?: boolean;
+    
+    propagateTags?: PropagateTags | string;
+    
+    enableExecuteCommand?: boolean;
+}
+export declare namespace Service {
+    
+    const filterSensitiveLog: (obj: Service) => any;
+}
+export interface CreateServiceResponse {
+    
+    service?: Service;
+}
+export declare namespace CreateServiceResponse {
+    
+    const filterSensitiveLog: (obj: CreateServiceResponse) => any;
+}
+
+export declare class PlatformTaskDefinitionIncompatibilityException extends __BaseException {
+    readonly name: "PlatformTaskDefinitionIncompatibilityException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PlatformTaskDefinitionIncompatibilityException, __BaseException>);
+}
+
+export declare class PlatformUnknownException extends __BaseException {
+    readonly name: "PlatformUnknownException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PlatformUnknownException, __BaseException>);
+}
+
+export declare class UnsupportedFeatureException extends __BaseException {
+    readonly name: "UnsupportedFeatureException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedFeatureException, __BaseException>);
+}
+export interface CreateTaskSetRequest {
+    
+    service: string | undefined;
+    
+    cluster: string | undefined;
+    
+    externalId?: string;
+    
+    taskDefinition: string | undefined;
+    
+    networkConfiguration?: NetworkConfiguration;
+    
+    loadBalancers?: LoadBalancer[];
+    
+    serviceRegistries?: ServiceRegistry[];
+    
+    launchType?: LaunchType | string;
+    
+    capacityProviderStrategy?: CapacityProviderStrategyItem[];
+    
+    platformVersion?: string;
+    
+    scale?: Scale;
+    
+    clientToken?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateTaskSetRequest {
+    
+    const filterSensitiveLog: (obj: CreateTaskSetRequest) => any;
+}
+export interface CreateTaskSetResponse {
+    
+    taskSet?: TaskSet;
+}
+export declare namespace CreateTaskSetResponse {
+    
+    const filterSensitiveLog: (obj: CreateTaskSetResponse) => any;
+}
+
+export declare class ServiceNotActiveException extends __BaseException {
+    readonly name: "ServiceNotActiveException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ServiceNotActiveException, __BaseException>);
+}
+
+export declare class ServiceNotFoundException extends __BaseException {
+    readonly name: "ServiceNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ServiceNotFoundException, __BaseException>);
+}
+export declare enum SettingName {
+    AWSVPC_TRUNKING = "awsvpcTrunking",
+    CONTAINER_INSIGHTS = "containerInsights",
+    CONTAINER_INSTANCE_LONG_ARN_FORMAT = "containerInstanceLongArnFormat",
+    SERVICE_LONG_ARN_FORMAT = "serviceLongArnFormat",
+    TASK_LONG_ARN_FORMAT = "taskLongArnFormat"
+}
+export interface DeleteAccountSettingRequest {
+    
+    name: SettingName | string | undefined;
+    
+    principalArn?: string;
+}
+export declare namespace DeleteAccountSettingRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAccountSettingRequest) => any;
+}
+
+export interface Setting {
+    
+    name?: SettingName | string;
+    
+    value?: string;
+    
+    principalArn?: string;
+}
+export declare namespace Setting {
+    
+    const filterSensitiveLog: (obj: Setting) => any;
+}
+export interface DeleteAccountSettingResponse {
+    
+    setting?: Setting;
+}
+export declare namespace DeleteAccountSettingResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAccountSettingResponse) => any;
+}
+export declare enum TargetType {
+    CONTAINER_INSTANCE = "container-instance"
+}
+
+export interface Attribute {
+    
+    name: string | undefined;
+    
+    value?: string;
+    
+    targetType?: TargetType | string;
+    
+    targetId?: string;
+}
+export declare namespace Attribute {
+    
+    const filterSensitiveLog: (obj: Attribute) => any;
+}
+export interface DeleteAttributesRequest {
+    
+    cluster?: string;
+    
+    attributes: Attribute[] | undefined;
+}
+export declare namespace DeleteAttributesRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAttributesRequest) => any;
+}
+export interface DeleteAttributesResponse {
+    
+    attributes?: Attribute[];
+}
+export declare namespace DeleteAttributesResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAttributesResponse) => any;
+}
+
+export declare class TargetNotFoundException extends __BaseException {
+    readonly name: "TargetNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TargetNotFoundException, __BaseException>);
+}
+export interface DeleteCapacityProviderRequest {
+    
+    capacityProvider: string | undefined;
+}
+export declare namespace DeleteCapacityProviderRequest {
+    
+    const filterSensitiveLog: (obj: DeleteCapacityProviderRequest) => any;
+}
+export interface DeleteCapacityProviderResponse {
+    
+    capacityProvider?: CapacityProvider;
+}
+export declare namespace DeleteCapacityProviderResponse {
+    
+    const filterSensitiveLog: (obj: DeleteCapacityProviderResponse) => any;
+}
+
+export declare class ClusterContainsContainerInstancesException extends __BaseException {
+    readonly name: "ClusterContainsContainerInstancesException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterContainsContainerInstancesException, __BaseException>);
+}
+
+export declare class ClusterContainsServicesException extends __BaseException {
+    readonly name: "ClusterContainsServicesException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterContainsServicesException, __BaseException>);
+}
+
+export declare class ClusterContainsTasksException extends __BaseException {
+    readonly name: "ClusterContainsTasksException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClusterContainsTasksException, __BaseException>);
+}
+export interface DeleteClusterRequest {
+    
+    cluster: string | undefined;
+}
+export declare namespace DeleteClusterRequest {
+    
+    const filterSensitiveLog: (obj: DeleteClusterRequest) => any;
+}
+export interface DeleteClusterResponse {
+    
+    cluster?: Cluster;
+}
+export declare namespace DeleteClusterResponse {
+    
+    const filterSensitiveLog: (obj: DeleteClusterResponse) => any;
+}
+export interface DeleteServiceRequest {
+    
+    cluster?: string;
+    
+    service: string | undefined;
+    
+    force?: boolean;
+}
+export declare namespace DeleteServiceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteServiceRequest) => any;
+}
+export interface DeleteServiceResponse {
+    
+    service?: Service;
+}
+export declare namespace DeleteServiceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteServiceResponse) => any;
+}
+export interface DeleteTaskSetRequest {
+    
+    cluster: string | undefined;
+    
+    service: string | undefined;
+    
+    taskSet: string | undefined;
+    
+    force?: boolean;
+}
+export declare namespace DeleteTaskSetRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTaskSetRequest) => any;
+}
+export interface DeleteTaskSetResponse {
+    
+    taskSet?: TaskSet;
+}
+export declare namespace DeleteTaskSetResponse {
+    
+    const filterSensitiveLog: (obj: DeleteTaskSetResponse) => any;
+}
+
+export declare class TaskSetNotFoundException extends __BaseException {
+    readonly name: "TaskSetNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TaskSetNotFoundException, __BaseException>);
+}
+export interface DeregisterContainerInstanceRequest {
+    
+    cluster?: string;
+    
+    containerInstance: string | undefined;
+    
+    force?: boolean;
+}
+export declare namespace DeregisterContainerInstanceRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterContainerInstanceRequest) => any;
+}
+export declare enum InstanceHealthCheckState {
+    IMPAIRED = "IMPAIRED",
+    INITIALIZING = "INITIALIZING",
+    INSUFFICIENT_DATA = "INSUFFICIENT_DATA",
+    OK = "OK"
+}
+export declare enum InstanceHealthCheckType {
+    CONTAINER_RUNTIME = "CONTAINER_RUNTIME"
+}
+
+export interface InstanceHealthCheckResult {
+    
+    type?: InstanceHealthCheckType | string;
+    
+    status?: InstanceHealthCheckState | string;
+    
+    lastUpdated?: Date;
+    
+    lastStatusChange?: Date;
+}
+export declare namespace InstanceHealthCheckResult {
+    
+    const filterSensitiveLog: (obj: InstanceHealthCheckResult) => any;
+}
+
+export interface ContainerInstanceHealthStatus {
+    
+    overallStatus?: InstanceHealthCheckState | string;
+    
+    details?: InstanceHealthCheckResult[];
+}
+export declare namespace ContainerInstanceHealthStatus {
+    
+    const filterSensitiveLog: (obj: ContainerInstanceHealthStatus) => any;
+}
+
+export interface Resource {
+    
+    name?: string;
+    
+    type?: string;
+    
+    doubleValue?: number;
+    
+    longValue?: number;
+    
+    integerValue?: number;
+    
+    stringSetValue?: string[];
+}
+export declare namespace Resource {
+    
+    const filterSensitiveLog: (obj: Resource) => any;
+}
+
+export interface VersionInfo {
+    
+    agentVersion?: string;
+    
+    agentHash?: string;
+    
+    dockerVersion?: string;
+}
+export declare namespace VersionInfo {
+    
+    const filterSensitiveLog: (obj: VersionInfo) => any;
+}
+
+export interface ContainerInstance {
+    
+    containerInstanceArn?: string;
+    
+    ec2InstanceId?: string;
+    
+    capacityProviderName?: string;
+    
+    version?: number;
+    
+    versionInfo?: VersionInfo;
+    
+    remainingResources?: Resource[];
+    
+    registeredResources?: Resource[];
+    
+    status?: string;
+    
+    statusReason?: string;
+    
+    agentConnected?: boolean;
+    
+    runningTasksCount?: number;
+    
+    pendingTasksCount?: number;
+    
+    agentUpdateStatus?: AgentUpdateStatus | string;
+    
+    attributes?: Attribute[];
+    
+    registeredAt?: Date;
+    
+    attachments?: Attachment[];
+    
+    tags?: Tag[];
+    
+    healthStatus?: ContainerInstanceHealthStatus;
+}
+export declare namespace ContainerInstance {
+    
+    const filterSensitiveLog: (obj: ContainerInstance) => any;
+}
+export interface DeregisterContainerInstanceResponse {
+    
+    containerInstance?: ContainerInstance;
+}
+export declare namespace DeregisterContainerInstanceResponse {
+    
+    const filterSensitiveLog: (obj: DeregisterContainerInstanceResponse) => any;
+}
+export interface DeregisterTaskDefinitionRequest {
+    
+    taskDefinition: string | undefined;
+}
+export declare namespace DeregisterTaskDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterTaskDefinitionRequest) => any;
+}
+export declare enum Compatibility {
+    EC2 = "EC2",
+    EXTERNAL = "EXTERNAL",
+    FARGATE = "FARGATE"
+}
+export declare enum ContainerCondition {
+    COMPLETE = "COMPLETE",
+    HEALTHY = "HEALTHY",
+    START = "START",
+    SUCCESS = "SUCCESS"
+}
+
+export interface ContainerDependency {
+    
+    containerName: string | undefined;
+    
+    condition: ContainerCondition | string | undefined;
+}
+export declare namespace ContainerDependency {
+    
+    const filterSensitiveLog: (obj: ContainerDependency) => any;
+}
+export declare enum EnvironmentFileType {
+    S3 = "s3"
+}
+
+export interface EnvironmentFile {
+    
+    value: string | undefined;
+    
+    type: EnvironmentFileType | string | undefined;
+}
+export declare namespace EnvironmentFile {
+    
+    const filterSensitiveLog: (obj: EnvironmentFile) => any;
+}
+
+export interface HostEntry {
+    
+    hostname: string | undefined;
+    
+    ipAddress: string | undefined;
+}
+export declare namespace HostEntry {
+    
+    const filterSensitiveLog: (obj: HostEntry) => any;
+}
+export declare enum FirelensConfigurationType {
+    FLUENTBIT = "fluentbit",
+    FLUENTD = "fluentd"
+}
+
+export interface FirelensConfiguration {
+    
+    type: FirelensConfigurationType | string | undefined;
+    
+    options?: {
+        [key: string]: string;
+    };
+}
+export declare namespace FirelensConfiguration {
+    
+    const filterSensitiveLog: (obj: FirelensConfiguration) => any;
+}
+
+export interface HealthCheck {
+    
+    command: string[] | undefined;
+    
+    interval?: number;
+    
+    timeout?: number;
+    
+    retries?: number;
+    
+    startPeriod?: number;
+}
+export declare namespace HealthCheck {
+    
+    const filterSensitiveLog: (obj: HealthCheck) => any;
+}
+
+export interface KernelCapabilities {
+    
+    add?: string[];
+    
+    drop?: string[];
+}
+export declare namespace KernelCapabilities {
+    
+    const filterSensitiveLog: (obj: KernelCapabilities) => any;
+}
+export declare enum DeviceCgroupPermission {
+    MKNOD = "mknod",
+    READ = "read",
+    WRITE = "write"
+}
+
+export interface Device {
+    
+    hostPath: string | undefined;
+    
+    containerPath?: string;
+    
+    permissions?: (DeviceCgroupPermission | string)[];
+}
+export declare namespace Device {
+    
+    const filterSensitiveLog: (obj: Device) => any;
+}
+
+export interface Tmpfs {
+    
+    containerPath: string | undefined;
+    
+    size: number | undefined;
+    
+    mountOptions?: string[];
+}
+export declare namespace Tmpfs {
+    
+    const filterSensitiveLog: (obj: Tmpfs) => any;
+}
+
+export interface LinuxParameters {
+    
+    capabilities?: KernelCapabilities;
+    
+    devices?: Device[];
+    
+    initProcessEnabled?: boolean;
+    
+    sharedMemorySize?: number;
+    
+    tmpfs?: Tmpfs[];
+    
+    maxSwap?: number;
+    
+    swappiness?: number;
+}
+export declare namespace LinuxParameters {
+    
+    const filterSensitiveLog: (obj: LinuxParameters) => any;
+}
+export declare enum LogDriver {
+    AWSFIRELENS = "awsfirelens",
+    AWSLOGS = "awslogs",
+    FLUENTD = "fluentd",
+    GELF = "gelf",
+    JOURNALD = "journald",
+    JSON_FILE = "json-file",
+    SPLUNK = "splunk",
+    SYSLOG = "syslog"
+}
+
+export interface Secret {
+    
+    name: string | undefined;
+    
+    valueFrom: string | undefined;
+}
+export declare namespace Secret {
+    
+    const filterSensitiveLog: (obj: Secret) => any;
+}
+
+export interface LogConfiguration {
+    
+    logDriver: LogDriver | string | undefined;
+    
+    options?: {
+        [key: string]: string;
+    };
+    
+    secretOptions?: Secret[];
+}
+export declare namespace LogConfiguration {
+    
+    const filterSensitiveLog: (obj: LogConfiguration) => any;
+}
+
+export interface MountPoint {
+    
+    sourceVolume?: string;
+    
+    containerPath?: string;
+    
+    readOnly?: boolean;
+}
+export declare namespace MountPoint {
+    
+    const filterSensitiveLog: (obj: MountPoint) => any;
+}
+export declare enum TransportProtocol {
+    TCP = "tcp",
+    UDP = "udp"
+}
+
+export interface PortMapping {
+    
+    containerPort?: number;
+    
+    hostPort?: number;
+    
+    protocol?: TransportProtocol | string;
+}
+export declare namespace PortMapping {
+    
+    const filterSensitiveLog: (obj: PortMapping) => any;
+}
+
+export interface RepositoryCredentials {
+    
+    credentialsParameter: string | undefined;
+}
+export declare namespace RepositoryCredentials {
+    
+    const filterSensitiveLog: (obj: RepositoryCredentials) => any;
+}
+export declare enum ResourceType {
+    GPU = "GPU",
+    INFERENCE_ACCELERATOR = "InferenceAccelerator"
+}
+
+export interface ResourceRequirement {
+    
+    value: string | undefined;
+    
+    type: ResourceType | string | undefined;
+}
+export declare namespace ResourceRequirement {
+    
+    const filterSensitiveLog: (obj: ResourceRequirement) => any;
+}
+
+export interface SystemControl {
+    
+    namespace?: string;
+    
+    value?: string;
+}
+export declare namespace SystemControl {
+    
+    const filterSensitiveLog: (obj: SystemControl) => any;
+}
+export declare enum UlimitName {
+    CORE = "core",
+    CPU = "cpu",
+    DATA = "data",
+    FSIZE = "fsize",
+    LOCKS = "locks",
+    MEMLOCK = "memlock",
+    MSGQUEUE = "msgqueue",
+    NICE = "nice",
+    NOFILE = "nofile",
+    NPROC = "nproc",
+    RSS = "rss",
+    RTPRIO = "rtprio",
+    RTTIME = "rttime",
+    SIGPENDING = "sigpending",
+    STACK = "stack"
+}
+
+export interface Ulimit {
+    
+    name: UlimitName | string | undefined;
+    
+    softLimit: number | undefined;
+    
+    hardLimit: number | undefined;
+}
+export declare namespace Ulimit {
+    
+    const filterSensitiveLog: (obj: Ulimit) => any;
+}
+
+export interface VolumeFrom {
+    
+    sourceContainer?: string;
+    
+    readOnly?: boolean;
+}
+export declare namespace VolumeFrom {
+    
+    const filterSensitiveLog: (obj: VolumeFrom) => any;
+}
+
+export interface ContainerDefinition {
+    
+    name?: string;
+    
+    image?: string;
+    
+    repositoryCredentials?: RepositoryCredentials;
+    
+    cpu?: number;
+    
+    memory?: number;
+    
+    memoryReservation?: number;
+    
+    links?: string[];
+    
+    portMappings?: PortMapping[];
+    
+    essential?: boolean;
+    
+    entryPoint?: string[];
+    
+    command?: string[];
+    
+    environment?: KeyValuePair[];
+    
+    environmentFiles?: EnvironmentFile[];
+    
+    mountPoints?: MountPoint[];
+    
+    volumesFrom?: VolumeFrom[];
+    
+    linuxParameters?: LinuxParameters;
+    
+    secrets?: Secret[];
+    
+    dependsOn?: ContainerDependency[];
+    
+    startTimeout?: number;
+    
+    stopTimeout?: number;
+    
+    hostname?: string;
+    
+    user?: string;
+    
+    workingDirectory?: string;
+    
+    disableNetworking?: boolean;
+    
+    privileged?: boolean;
+    
+    readonlyRootFilesystem?: boolean;
+    
+    dnsServers?: string[];
+    
+    dnsSearchDomains?: string[];
+    
+    extraHosts?: HostEntry[];
+    
+    dockerSecurityOptions?: string[];
+    
+    interactive?: boolean;
+    
+    pseudoTerminal?: boolean;
+    
+    dockerLabels?: {
+        [key: string]: string;
+    };
+    
+    ulimits?: Ulimit[];
+    
+    logConfiguration?: LogConfiguration;
+    
+    healthCheck?: HealthCheck;
+    
+    systemControls?: SystemControl[];
+    
+    resourceRequirements?: ResourceRequirement[];
+    
+    firelensConfiguration?: FirelensConfiguration;
+}
+export declare namespace ContainerDefinition {
+    
+    const filterSensitiveLog: (obj: ContainerDefinition) => any;
+}
+
+export interface EphemeralStorage {
+    
+    sizeInGiB: number | undefined;
+}
+export declare namespace EphemeralStorage {
+    
+    const filterSensitiveLog: (obj: EphemeralStorage) => any;
+}
+
+export interface InferenceAccelerator {
+    
+    deviceName: string | undefined;
+    
+    deviceType: string | undefined;
+}
+export declare namespace InferenceAccelerator {
+    
+    const filterSensitiveLog: (obj: InferenceAccelerator) => any;
+}
+export declare enum IpcMode {
+    HOST = "host",
+    NONE = "none",
+    TASK = "task"
+}
+export declare enum NetworkMode {
+    AWSVPC = "awsvpc",
+    BRIDGE = "bridge",
+    HOST = "host",
+    NONE = "none"
+}
+export declare enum PidMode {
+    HOST = "host",
+    TASK = "task"
+}
+export declare enum TaskDefinitionPlacementConstraintType {
+    MEMBER_OF = "memberOf"
+}
+
+export interface TaskDefinitionPlacementConstraint {
+    
+    type?: TaskDefinitionPlacementConstraintType | string;
+    
+    expression?: string;
+}
+export declare namespace TaskDefinitionPlacementConstraint {
+    
+    const filterSensitiveLog: (obj: TaskDefinitionPlacementConstraint) => any;
+}
+export declare enum ProxyConfigurationType {
+    APPMESH = "APPMESH"
+}
+
+export interface ProxyConfiguration {
+    
+    type?: ProxyConfigurationType | string;
+    
+    containerName: string | undefined;
+    
+    properties?: KeyValuePair[];
+}
+export declare namespace ProxyConfiguration {
+    
+    const filterSensitiveLog: (obj: ProxyConfiguration) => any;
+}
+export declare enum CPUArchitecture {
+    ARM64 = "ARM64",
+    X86_64 = "X86_64"
+}
+export declare enum OSFamily {
+    LINUX = "LINUX",
+    WINDOWS_SERVER_2004_CORE = "WINDOWS_SERVER_2004_CORE",
+    WINDOWS_SERVER_2016_FULL = "WINDOWS_SERVER_2016_FULL",
+    WINDOWS_SERVER_2019_CORE = "WINDOWS_SERVER_2019_CORE",
+    WINDOWS_SERVER_2019_FULL = "WINDOWS_SERVER_2019_FULL",
+    WINDOWS_SERVER_2022_CORE = "WINDOWS_SERVER_2022_CORE",
+    WINDOWS_SERVER_2022_FULL = "WINDOWS_SERVER_2022_FULL",
+    WINDOWS_SERVER_20H2_CORE = "WINDOWS_SERVER_20H2_CORE"
+}
+
+export interface RuntimePlatform {
+    
+    cpuArchitecture?: CPUArchitecture | string;
+    
+    operatingSystemFamily?: OSFamily | string;
+}
+export declare namespace RuntimePlatform {
+    
+    const filterSensitiveLog: (obj: RuntimePlatform) => any;
+}
+export declare enum TaskDefinitionStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+export declare enum Scope {
+    SHARED = "shared",
+    TASK = "task"
+}
+
+export interface DockerVolumeConfiguration {
+    
+    scope?: Scope | string;
+    
+    autoprovision?: boolean;
+    
+    driver?: string;
+    
+    driverOpts?: {
+        [key: string]: string;
+    };
+    
+    labels?: {
+        [key: string]: string;
+    };
+}
+export declare namespace DockerVolumeConfiguration {
+    
+    const filterSensitiveLog: (obj: DockerVolumeConfiguration) => any;
+}
+export declare enum EFSAuthorizationConfigIAM {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface EFSAuthorizationConfig {
+    
+    accessPointId?: string;
+    
+    iam?: EFSAuthorizationConfigIAM | string;
+}
+export declare namespace EFSAuthorizationConfig {
+    
+    const filterSensitiveLog: (obj: EFSAuthorizationConfig) => any;
+}
+export declare enum EFSTransitEncryption {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface EFSVolumeConfiguration {
+    
+    fileSystemId: string | undefined;
+    
+    rootDirectory?: string;
+    
+    transitEncryption?: EFSTransitEncryption | string;
+    
+    transitEncryptionPort?: number;
+    
+    authorizationConfig?: EFSAuthorizationConfig;
+}
+export declare namespace EFSVolumeConfiguration {
+    
+    const filterSensitiveLog: (obj: EFSVolumeConfiguration) => any;
+}
+
+export interface FSxWindowsFileServerAuthorizationConfig {
+    
+    credentialsParameter: string | undefined;
+    
+    domain: string | undefined;
+}
+export declare namespace FSxWindowsFileServerAuthorizationConfig {
+    
+    const filterSensitiveLog: (obj: FSxWindowsFileServerAuthorizationConfig) => any;
+}
+
+export interface FSxWindowsFileServerVolumeConfiguration {
+    
+    fileSystemId: string | undefined;
+    
+    rootDirectory: string | undefined;
+    
+    authorizationConfig: FSxWindowsFileServerAuthorizationConfig | undefined;
+}
+export declare namespace FSxWindowsFileServerVolumeConfiguration {
+    
+    const filterSensitiveLog: (obj: FSxWindowsFileServerVolumeConfiguration) => any;
+}
+
+export interface HostVolumeProperties {
+    
+    sourcePath?: string;
+}
+export declare namespace HostVolumeProperties {
+    
+    const filterSensitiveLog: (obj: HostVolumeProperties) => any;
+}
+
+export interface Volume {
+    
+    name?: string;
+    
+    host?: HostVolumeProperties;
+    
+    dockerVolumeConfiguration?: DockerVolumeConfiguration;
+    
+    efsVolumeConfiguration?: EFSVolumeConfiguration;
+    
+    fsxWindowsFileServerVolumeConfiguration?: FSxWindowsFileServerVolumeConfiguration;
+}
+export declare namespace Volume {
+    
+    const filterSensitiveLog: (obj: Volume) => any;
+}
+
+export interface TaskDefinition {
+    
+    taskDefinitionArn?: string;
+    
+    containerDefinitions?: ContainerDefinition[];
+    
+    family?: string;
+    
+    taskRoleArn?: string;
+    
+    executionRoleArn?: string;
+    
+    networkMode?: NetworkMode | string;
+    
+    revision?: number;
+    
+    volumes?: Volume[];
+    
+    status?: TaskDefinitionStatus | string;
+    
+    requiresAttributes?: Attribute[];
+    
+    placementConstraints?: TaskDefinitionPlacementConstraint[];
+    
+    compatibilities?: (Compatibility | string)[];
+    
+    runtimePlatform?: RuntimePlatform;
+    
+    requiresCompatibilities?: (Compatibility | string)[];
+    
+    cpu?: string;
+    
+    memory?: string;
+    
+    inferenceAccelerators?: InferenceAccelerator[];
+    
+    pidMode?: PidMode | string;
+    
+    ipcMode?: IpcMode | string;
+    
+    proxyConfiguration?: ProxyConfiguration;
+    
+    registeredAt?: Date;
+    
+    deregisteredAt?: Date;
+    
+    registeredBy?: string;
+    
+    ephemeralStorage?: EphemeralStorage;
+}
+export declare namespace TaskDefinition {
+    
+    const filterSensitiveLog: (obj: TaskDefinition) => any;
+}
+export interface DeregisterTaskDefinitionResponse {
+    
+    taskDefinition?: TaskDefinition;
+}
+export declare namespace DeregisterTaskDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeregisterTaskDefinitionResponse) => any;
+}
+export declare enum CapacityProviderField {
+    TAGS = "TAGS"
+}
+export interface DescribeCapacityProvidersRequest {
+    
+    capacityProviders?: string[];
+    
+    include?: (CapacityProviderField | string)[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeCapacityProvidersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCapacityProvidersRequest) => any;
+}
+
+export interface Failure {
+    
+    arn?: string;
+    
+    reason?: string;
+    
+    detail?: string;
+}
+export declare namespace Failure {
+    
+    const filterSensitiveLog: (obj: Failure) => any;
+}
+export interface DescribeCapacityProvidersResponse {
+    
+    capacityProviders?: CapacityProvider[];
+    
+    failures?: Failure[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeCapacityProvidersResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCapacityProvidersResponse) => any;
+}
+export declare enum ClusterField {
+    ATTACHMENTS = "ATTACHMENTS",
+    CONFIGURATIONS = "CONFIGURATIONS",
+    SETTINGS = "SETTINGS",
+    STATISTICS = "STATISTICS",
+    TAGS = "TAGS"
+}
+export interface DescribeClustersRequest {
+    
+    clusters?: string[];
+    
+    include?: (ClusterField | string)[];
+}
+export declare namespace DescribeClustersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeClustersRequest) => any;
+}
+export interface DescribeClustersResponse {
+    
+    clusters?: Cluster[];
+    
+    failures?: Failure[];
+}
+export declare namespace DescribeClustersResponse {
+    
+    const filterSensitiveLog: (obj: DescribeClustersResponse) => any;
+}
+export declare enum ContainerInstanceField {
+    CONTAINER_INSTANCE_HEALTH = "CONTAINER_INSTANCE_HEALTH",
+    TAGS = "TAGS"
+}
+export interface DescribeContainerInstancesRequest {
+    
+    cluster?: string;
+    
+    containerInstances: string[] | undefined;
+    
+    include?: (ContainerInstanceField | string)[];
+}
+export declare namespace DescribeContainerInstancesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeContainerInstancesRequest) => any;
+}
+export interface DescribeContainerInstancesResponse {
+    
+    containerInstances?: ContainerInstance[];
+    
+    failures?: Failure[];
+}
+export declare namespace DescribeContainerInstancesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeContainerInstancesResponse) => any;
+}
+export declare enum ServiceField {
+    TAGS = "TAGS"
+}
+export interface DescribeServicesRequest {
+    
+    cluster?: string;
+    
+    services: string[] | undefined;
+    
+    include?: (ServiceField | string)[];
+}
+export declare namespace DescribeServicesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeServicesRequest) => any;
+}
+export interface DescribeServicesResponse {
+    
+    services?: Service[];
+    
+    failures?: Failure[];
+}
+export declare namespace DescribeServicesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeServicesResponse) => any;
+}
+export declare enum TaskDefinitionField {
+    TAGS = "TAGS"
+}
+export interface DescribeTaskDefinitionRequest {
+    
+    taskDefinition: string | undefined;
+    
+    include?: (TaskDefinitionField | string)[];
+}
+export declare namespace DescribeTaskDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeTaskDefinitionRequest) => any;
+}
+export interface DescribeTaskDefinitionResponse {
+    
+    taskDefinition?: TaskDefinition;
+    
+    tags?: Tag[];
+}
+export declare namespace DescribeTaskDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeTaskDefinitionResponse) => any;
+}
+export declare enum TaskField {
+    TAGS = "TAGS"
+}
+export interface DescribeTasksRequest {
+    
+    cluster?: string;
+    
+    tasks: string[] | undefined;
+    
+    include?: (TaskField | string)[];
+}
+export declare namespace DescribeTasksRequest {
+    
+    const filterSensitiveLog: (obj: DescribeTasksRequest) => any;
+}
+export declare enum Connectivity {
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED"
+}
+export declare enum HealthStatus {
+    HEALTHY = "HEALTHY",
+    UNHEALTHY = "UNHEALTHY",
+    UNKNOWN = "UNKNOWN"
+}
+export declare enum ManagedAgentName {
+    ExecuteCommandAgent = "ExecuteCommandAgent"
+}
+
+export interface ManagedAgent {
+    
+    lastStartedAt?: Date;
+    
+    name?: ManagedAgentName | string;
+    
+    reason?: string;
+    
+    lastStatus?: string;
+}
+export declare namespace ManagedAgent {
+    
+    const filterSensitiveLog: (obj: ManagedAgent) => any;
+}
+
+export interface NetworkBinding {
+    
+    bindIP?: string;
+    
+    containerPort?: number;
+    
+    hostPort?: number;
+    
+    protocol?: TransportProtocol | string;
+}
+export declare namespace NetworkBinding {
+    
+    const filterSensitiveLog: (obj: NetworkBinding) => any;
+}
+
+export interface NetworkInterface {
+    
+    attachmentId?: string;
+    
+    privateIpv4Address?: string;
+    
+    ipv6Address?: string;
+}
+export declare namespace NetworkInterface {
+    
+    const filterSensitiveLog: (obj: NetworkInterface) => any;
+}
+
+export interface Container {
+    
+    containerArn?: string;
+    
+    taskArn?: string;
+    
+    name?: string;
+    
+    image?: string;
+    
+    imageDigest?: string;
+    
+    runtimeId?: string;
+    
+    lastStatus?: string;
+    
+    exitCode?: number;
+    
+    reason?: string;
+    
+    networkBindings?: NetworkBinding[];
+    
+    networkInterfaces?: NetworkInterface[];
+    
+    healthStatus?: HealthStatus | string;
+    
+    managedAgents?: ManagedAgent[];
+    
+    cpu?: string;
+    
+    memory?: string;
+    
+    memoryReservation?: string;
+    
+    gpuIds?: string[];
+}
+export declare namespace Container {
+    
+    const filterSensitiveLog: (obj: Container) => any;
+}
+
+export interface ContainerOverride {
+    
+    name?: string;
+    
+    command?: string[];
+    
+    environment?: KeyValuePair[];
+    
+    environmentFiles?: EnvironmentFile[];
+    
+    cpu?: number;
+    
+    memory?: number;
+    
+    memoryReservation?: number;
+    
+    resourceRequirements?: ResourceRequirement[];
+}
+export declare namespace ContainerOverride {
+    
+    const filterSensitiveLog: (obj: ContainerOverride) => any;
+}
+
+export interface InferenceAcceleratorOverride {
+    
+    deviceName?: string;
+    
+    deviceType?: string;
+}
+export declare namespace InferenceAcceleratorOverride {
+    
+    const filterSensitiveLog: (obj: InferenceAcceleratorOverride) => any;
+}
+
+export interface TaskOverride {
+    
+    containerOverrides?: ContainerOverride[];
+    
+    cpu?: string;
+    
+    inferenceAcceleratorOverrides?: InferenceAcceleratorOverride[];
+    
+    executionRoleArn?: string;
+    
+    memory?: string;
+    
+    taskRoleArn?: string;
+    
+    ephemeralStorage?: EphemeralStorage;
+}
+export declare namespace TaskOverride {
+    
+    const filterSensitiveLog: (obj: TaskOverride) => any;
+}
+export declare enum TaskStopCode {
+    ESSENTIAL_CONTAINER_EXITED = "EssentialContainerExited",
+    TASK_FAILED_TO_START = "TaskFailedToStart",
+    USER_INITIATED = "UserInitiated"
+}
+
+export interface Task {
+    
+    attachments?: Attachment[];
+    
+    attributes?: Attribute[];
+    
+    availabilityZone?: string;
+    
+    capacityProviderName?: string;
+    
+    clusterArn?: string;
+    
+    connectivity?: Connectivity | string;
+    
+    connectivityAt?: Date;
+    
+    containerInstanceArn?: string;
+    
+    containers?: Container[];
+    
+    cpu?: string;
+    
+    createdAt?: Date;
+    
+    desiredStatus?: string;
+    
+    enableExecuteCommand?: boolean;
+    
+    executionStoppedAt?: Date;
+    
+    group?: string;
+    
+    healthStatus?: HealthStatus | string;
+    
+    inferenceAccelerators?: InferenceAccelerator[];
+    
+    lastStatus?: string;
+    
+    launchType?: LaunchType | string;
+    
+    memory?: string;
+    
+    overrides?: TaskOverride;
+    
+    platformVersion?: string;
+    
+    platformFamily?: string;
+    
+    pullStartedAt?: Date;
+    
+    pullStoppedAt?: Date;
+    
+    startedAt?: Date;
+    
+    startedBy?: string;
+    
+    stopCode?: TaskStopCode | string;
+    
+    stoppedAt?: Date;
+    
+    stoppedReason?: string;
+    
+    stoppingAt?: Date;
+    
+    tags?: Tag[];
+    
+    taskArn?: string;
+    
+    taskDefinitionArn?: string;
+    
+    version?: number;
+    
+    ephemeralStorage?: EphemeralStorage;
+}
+export declare namespace Task {
+    
+    const filterSensitiveLog: (obj: Task) => any;
+}
+export interface DescribeTasksResponse {
+    
+    tasks?: Task[];
+    
+    failures?: Failure[];
+}
+export declare namespace DescribeTasksResponse {
+    
+    const filterSensitiveLog: (obj: DescribeTasksResponse) => any;
+}
+export declare enum TaskSetField {
+    TAGS = "TAGS"
+}
+export interface DescribeTaskSetsRequest {
+    
+    cluster: string | undefined;
+    
+    service: string | undefined;
+    
+    taskSets?: string[];
+    
+    include?: (TaskSetField | string)[];
+}
+export declare namespace DescribeTaskSetsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeTaskSetsRequest) => any;
+}
+export interface DescribeTaskSetsResponse {
+    
+    taskSets?: TaskSet[];
+    
+    failures?: Failure[];
+}
+export declare namespace DescribeTaskSetsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeTaskSetsResponse) => any;
+}
+export interface DiscoverPollEndpointRequest {
+    
+    containerInstance?: string;
+    
+    cluster?: string;
+}
+export declare namespace DiscoverPollEndpointRequest {
+    
+    const filterSensitiveLog: (obj: DiscoverPollEndpointRequest) => any;
+}
+export interface DiscoverPollEndpointResponse {
+    
+    endpoint?: string;
+    
+    telemetryEndpoint?: string;
+}
+export declare namespace DiscoverPollEndpointResponse {
+    
+    const filterSensitiveLog: (obj: DiscoverPollEndpointResponse) => any;
+}
+export interface ExecuteCommandRequest {
+    
+    cluster?: string;
+    
+    container?: string;
+    
+    command: string | undefined;
+    
+    interactive: boolean | undefined;
+    
+    task: string | undefined;
+}
+export declare namespace ExecuteCommandRequest {
+    
+    const filterSensitiveLog: (obj: ExecuteCommandRequest) => any;
+}
+
+export interface Session {
+    
+    sessionId?: string;
+    
+    streamUrl?: string;
+    
+    tokenValue?: string;
+}
+export declare namespace Session {
+    
+    const filterSensitiveLog: (obj: Session) => any;
+}
+export interface ExecuteCommandResponse {
+    
+    clusterArn?: string;
+    
+    containerArn?: string;
+    
+    containerName?: string;
+    
+    interactive?: boolean;
+    
+    session?: Session;
+    
+    taskArn?: string;
+}
+export declare namespace ExecuteCommandResponse {
+    
+    const filterSensitiveLog: (obj: ExecuteCommandResponse) => any;
+}
+
+export declare class TargetNotConnectedException extends __BaseException {
+    readonly name: "TargetNotConnectedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TargetNotConnectedException, __BaseException>);
+}
+export interface ListAccountSettingsRequest {
+    
+    name?: SettingName | string;
+    
+    value?: string;
+    
+    principalArn?: string;
+    
+    effectiveSettings?: boolean;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListAccountSettingsRequest {
+    
+    const filterSensitiveLog: (obj: ListAccountSettingsRequest) => any;
+}
+export interface ListAccountSettingsResponse {
+    
+    settings?: Setting[];
+    
+    nextToken?: string;
+}
+export declare namespace ListAccountSettingsResponse {
+    
+    const filterSensitiveLog: (obj: ListAccountSettingsResponse) => any;
+}
+export interface ListAttributesRequest {
+    
+    cluster?: string;
+    
+    targetType: TargetType | string | undefined;
+    
+    attributeName?: string;
+    
+    attributeValue?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListAttributesRequest {
+    
+    const filterSensitiveLog: (obj: ListAttributesRequest) => any;
+}
+export interface ListAttributesResponse {
+    
+    attributes?: Attribute[];
+    
+    nextToken?: string;
+}
+export declare namespace ListAttributesResponse {
+    
+    const filterSensitiveLog: (obj: ListAttributesResponse) => any;
+}
+export interface ListClustersRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListClustersRequest {
+    
+    const filterSensitiveLog: (obj: ListClustersRequest) => any;
+}
+export interface ListClustersResponse {
+    
+    clusterArns?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListClustersResponse {
+    
+    const filterSensitiveLog: (obj: ListClustersResponse) => any;
+}
+export declare enum ContainerInstanceStatus {
+    ACTIVE = "ACTIVE",
+    DEREGISTERING = "DEREGISTERING",
+    DRAINING = "DRAINING",
+    REGISTERING = "REGISTERING",
+    REGISTRATION_FAILED = "REGISTRATION_FAILED"
+}
+export interface ListContainerInstancesRequest {
+    
+    cluster?: string;
+    
+    filter?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    status?: ContainerInstanceStatus | string;
+}
+export declare namespace ListContainerInstancesRequest {
+    
+    const filterSensitiveLog: (obj: ListContainerInstancesRequest) => any;
+}
+export interface ListContainerInstancesResponse {
+    
+    containerInstanceArns?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListContainerInstancesResponse {
+    
+    const filterSensitiveLog: (obj: ListContainerInstancesResponse) => any;
+}
+export interface ListServicesRequest {
+    
+    cluster?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    launchType?: LaunchType | string;
+    
+    schedulingStrategy?: SchedulingStrategy | string;
+}
+export declare namespace ListServicesRequest {
+    
+    const filterSensitiveLog: (obj: ListServicesRequest) => any;
+}
+export interface ListServicesResponse {
+    
+    serviceArns?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListServicesResponse {
+    
+    const filterSensitiveLog: (obj: ListServicesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export declare enum TaskDefinitionFamilyStatus {
+    ACTIVE = "ACTIVE",
+    ALL = "ALL",
+    INACTIVE = "INACTIVE"
+}
+export interface ListTaskDefinitionFamiliesRequest {
+    
+    familyPrefix?: string;
+    
+    status?: TaskDefinitionFamilyStatus | string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListTaskDefinitionFamiliesRequest {
+    
+    const filterSensitiveLog: (obj: ListTaskDefinitionFamiliesRequest) => any;
+}
+export interface ListTaskDefinitionFamiliesResponse {
+    
+    families?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTaskDefinitionFamiliesResponse {
+    
+    const filterSensitiveLog: (obj: ListTaskDefinitionFamiliesResponse) => any;
+}
+export declare enum SortOrder {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+export interface ListTaskDefinitionsRequest {
+    
+    familyPrefix?: string;
+    
+    status?: TaskDefinitionStatus | string;
+    
+    sort?: SortOrder | string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListTaskDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: ListTaskDefinitionsRequest) => any;
+}
+export interface ListTaskDefinitionsResponse {
+    
+    taskDefinitionArns?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTaskDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: ListTaskDefinitionsResponse) => any;
+}
+export declare enum DesiredStatus {
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    STOPPED = "STOPPED"
+}
+export interface ListTasksRequest {
+    
+    cluster?: string;
+    
+    containerInstance?: string;
+    
+    family?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    startedBy?: string;
+    
+    serviceName?: string;
+    
+    desiredStatus?: DesiredStatus | string;
+    
+    launchType?: LaunchType | string;
+}
+export declare namespace ListTasksRequest {
+    
+    const filterSensitiveLog: (obj: ListTasksRequest) => any;
+}
+export interface ListTasksResponse {
+    
+    taskArns?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTasksResponse {
+    
+    const filterSensitiveLog: (obj: ListTasksResponse) => any;
+}
+export interface PutAccountSettingRequest {
+    
+    name: SettingName | string | undefined;
+    
+    value: string | undefined;
+    
+    principalArn?: string;
+}
+export declare namespace PutAccountSettingRequest {
+    
+    const filterSensitiveLog: (obj: PutAccountSettingRequest) => any;
+}
+export interface PutAccountSettingResponse {
+    
+    setting?: Setting;
+}
+export declare namespace PutAccountSettingResponse {
+    
+    const filterSensitiveLog: (obj: PutAccountSettingResponse) => any;
+}
+export interface PutAccountSettingDefaultRequest {
+    
+    name: SettingName | string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace PutAccountSettingDefaultRequest {
+    
+    const filterSensitiveLog: (obj: PutAccountSettingDefaultRequest) => any;
+}
+export interface PutAccountSettingDefaultResponse {
+    
+    setting?: Setting;
+}
+export declare namespace PutAccountSettingDefaultResponse {
+    
+    const filterSensitiveLog: (obj: PutAccountSettingDefaultResponse) => any;
+}
+
+export declare class AttributeLimitExceededException extends __BaseException {
+    readonly name: "AttributeLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AttributeLimitExceededException, __BaseException>);
+}
+export interface PutAttributesRequest {
+    
+    cluster?: string;
+    
+    attributes: Attribute[] | undefined;
+}
+export declare namespace PutAttributesRequest {
+    
+    const filterSensitiveLog: (obj: PutAttributesRequest) => any;
+}
+export interface PutAttributesResponse {
+    
+    attributes?: Attribute[];
+}
+export declare namespace PutAttributesResponse {
+    
+    const filterSensitiveLog: (obj: PutAttributesResponse) => any;
+}
+export interface PutClusterCapacityProvidersRequest {
+    
+    cluster: string | undefined;
+    
+    capacityProviders: string[] | undefined;
+    
+    defaultCapacityProviderStrategy: CapacityProviderStrategyItem[] | undefined;
+}
+export declare namespace PutClusterCapacityProvidersRequest {
+    
+    const filterSensitiveLog: (obj: PutClusterCapacityProvidersRequest) => any;
+}
+export interface PutClusterCapacityProvidersResponse {
+    
+    cluster?: Cluster;
+}
+export declare namespace PutClusterCapacityProvidersResponse {
+    
+    const filterSensitiveLog: (obj: PutClusterCapacityProvidersResponse) => any;
+}
+
+export declare class ResourceInUseException extends __BaseException {
+    readonly name: "ResourceInUseException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceInUseException, __BaseException>);
+}
+export declare enum PlatformDeviceType {
+    GPU = "GPU"
+}
+
+export interface PlatformDevice {
+    
+    id: string | undefined;
+    
+    type: PlatformDeviceType | string | undefined;
+}
+export declare namespace PlatformDevice {
+    
+    const filterSensitiveLog: (obj: PlatformDevice) => any;
+}
+export interface RegisterContainerInstanceRequest {
+    
+    cluster?: string;
+    
+    instanceIdentityDocument?: string;
+    
+    instanceIdentityDocumentSignature?: string;
+    
+    totalResources?: Resource[];
+    
+    versionInfo?: VersionInfo;
+    
+    containerInstanceArn?: string;
+    
+    attributes?: Attribute[];
+    
+    platformDevices?: PlatformDevice[];
+    
+    tags?: Tag[];
+}
+export declare namespace RegisterContainerInstanceRequest {
+    
+    const filterSensitiveLog: (obj: RegisterContainerInstanceRequest) => any;
+}
+export interface RegisterContainerInstanceResponse {
+    
+    containerInstance?: ContainerInstance;
+}
+export declare namespace RegisterContainerInstanceResponse {
+    
+    const filterSensitiveLog: (obj: RegisterContainerInstanceResponse) => any;
+}
+export interface RegisterTaskDefinitionRequest {
+    
+    family: string | undefined;
+    
+    taskRoleArn?: string;
+    
+    executionRoleArn?: string;
+    
+    networkMode?: NetworkMode | string;
+    
+    containerDefinitions: ContainerDefinition[] | undefined;
+    
+    volumes?: Volume[];
+    
+    placementConstraints?: TaskDefinitionPlacementConstraint[];
+    
+    requiresCompatibilities?: (Compatibility | string)[];
+    
+    cpu?: string;
+    
+    memory?: string;
+    
+    tags?: Tag[];
+    
+    pidMode?: PidMode | string;
+    
+    ipcMode?: IpcMode | string;
+    
+    proxyConfiguration?: ProxyConfiguration;
+    
+    inferenceAccelerators?: InferenceAccelerator[];
+    
+    ephemeralStorage?: EphemeralStorage;
+    
+    runtimePlatform?: RuntimePlatform;
+}
+export declare namespace RegisterTaskDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: RegisterTaskDefinitionRequest) => any;
+}
+export interface RegisterTaskDefinitionResponse {
+    
+    taskDefinition?: TaskDefinition;
+    
+    tags?: Tag[];
+}
+export declare namespace RegisterTaskDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: RegisterTaskDefinitionResponse) => any;
+}
+
+export declare class BlockedException extends __BaseException {
+    readonly name: "BlockedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BlockedException, __BaseException>);
+}
+export interface RunTaskRequest {
+    
+    capacityProviderStrategy?: CapacityProviderStrategyItem[];
+    
+    cluster?: string;
+    
+    count?: number;
+    
+    enableECSManagedTags?: boolean;
+    
+    enableExecuteCommand?: boolean;
+    
+    group?: string;
+    
+    launchType?: LaunchType | string;
+    
+    networkConfiguration?: NetworkConfiguration;
+    
+    overrides?: TaskOverride;
+    
+    placementConstraints?: PlacementConstraint[];
+    
+    placementStrategy?: PlacementStrategy[];
+    
+    platformVersion?: string;
+    
+    propagateTags?: PropagateTags | string;
+    
+    referenceId?: string;
+    
+    startedBy?: string;
+    
+    tags?: Tag[];
+    
+    taskDefinition: string | undefined;
+}
+export declare namespace RunTaskRequest {
+    
+    const filterSensitiveLog: (obj: RunTaskRequest) => any;
+}
+export interface RunTaskResponse {
+    
+    tasks?: Task[];
+    
+    failures?: Failure[];
+}
+export declare namespace RunTaskResponse {
+    
+    const filterSensitiveLog: (obj: RunTaskResponse) => any;
+}
+export interface StartTaskRequest {
+    
+    cluster?: string;
+    
+    containerInstances: string[] | undefined;
+    
+    enableECSManagedTags?: boolean;
+    
+    enableExecuteCommand?: boolean;
+    
+    group?: string;
+    
+    networkConfiguration?: NetworkConfiguration;
+    
+    overrides?: TaskOverride;
+    
+    propagateTags?: PropagateTags | string;
+    
+    referenceId?: string;
+    
+    startedBy?: string;
+    
+    tags?: Tag[];
+    
+    taskDefinition: string | undefined;
+}
+export declare namespace StartTaskRequest {
+    
+    const filterSensitiveLog: (obj: StartTaskRequest) => any;
+}
+export interface StartTaskResponse {
+    
+    tasks?: Task[];
+    
+    failures?: Failure[];
+}
+export declare namespace StartTaskResponse {
+    
+    const filterSensitiveLog: (obj: StartTaskResponse) => any;
+}
+export interface StopTaskRequest {
+    
+    cluster?: string;
+    
+    task: string | undefined;
+    
+    reason?: string;
+}
+export declare namespace StopTaskRequest {
+    
+    const filterSensitiveLog: (obj: StopTaskRequest) => any;
+}
+export interface StopTaskResponse {
+    
+    task?: Task;
+}
+export declare namespace StopTaskResponse {
+    
+    const filterSensitiveLog: (obj: StopTaskResponse) => any;
+}
+
+export interface AttachmentStateChange {
+    
+    attachmentArn: string | undefined;
+    
+    status: string | undefined;
+}
+export declare namespace AttachmentStateChange {
+    
+    const filterSensitiveLog: (obj: AttachmentStateChange) => any;
+}
+export interface SubmitAttachmentStateChangesRequest {
+    
+    cluster?: string;
+    
+    attachments: AttachmentStateChange[] | undefined;
+}
+export declare namespace SubmitAttachmentStateChangesRequest {
+    
+    const filterSensitiveLog: (obj: SubmitAttachmentStateChangesRequest) => any;
+}
+export interface SubmitAttachmentStateChangesResponse {
+    
+    acknowledgment?: string;
+}
+export declare namespace SubmitAttachmentStateChangesResponse {
+    
+    const filterSensitiveLog: (obj: SubmitAttachmentStateChangesResponse) => any;
+}
+export interface SubmitContainerStateChangeRequest {
+    
+    cluster?: string;
+    
+    task?: string;
+    
+    containerName?: string;
+    
+    runtimeId?: string;
+    
+    status?: string;
+    
+    exitCode?: number;
+    
+    reason?: string;
+    
+    networkBindings?: NetworkBinding[];
+}
+export declare namespace SubmitContainerStateChangeRequest {
+    
+    const filterSensitiveLog: (obj: SubmitContainerStateChangeRequest) => any;
+}
+export interface SubmitContainerStateChangeResponse {
+    
+    acknowledgment?: string;
+}
+export declare namespace SubmitContainerStateChangeResponse {
+    
+    const filterSensitiveLog: (obj: SubmitContainerStateChangeResponse) => any;
+}
+
+export interface ContainerStateChange {
+    
+    containerName?: string;
+    
+    imageDigest?: string;
+    
+    runtimeId?: string;
+    
+    exitCode?: number;
+    
+    networkBindings?: NetworkBinding[];
+    
+    reason?: string;
+    
+    status?: string;
+}
+export declare namespace ContainerStateChange {
+    
+    const filterSensitiveLog: (obj: ContainerStateChange) => any;
+}
+
+export interface ManagedAgentStateChange {
+    
+    containerName: string | undefined;
+    
+    managedAgentName: ManagedAgentName | string | undefined;
+    
+    status: string | undefined;
+    
+    reason?: string;
+}
+export declare namespace ManagedAgentStateChange {
+    
+    const filterSensitiveLog: (obj: ManagedAgentStateChange) => any;
+}
+export interface SubmitTaskStateChangeRequest {
+    
+    cluster?: string;
+    
+    task?: string;
+    
+    status?: string;
+    
+    reason?: string;
+    
+    containers?: ContainerStateChange[];
+    
+    attachments?: AttachmentStateChange[];
+    
+    managedAgents?: ManagedAgentStateChange[];
+    
+    pullStartedAt?: Date;
+    
+    pullStoppedAt?: Date;
+    
+    executionStoppedAt?: Date;
+}
+export declare namespace SubmitTaskStateChangeRequest {
+    
+    const filterSensitiveLog: (obj: SubmitTaskStateChangeRequest) => any;
+}
+export interface SubmitTaskStateChangeResponse {
+    
+    acknowledgment?: string;
+}
+export declare namespace SubmitTaskStateChangeResponse {
+    
+    const filterSensitiveLog: (obj: SubmitTaskStateChangeResponse) => any;
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+
+export interface AutoScalingGroupProviderUpdate {
+    
+    managedScaling?: ManagedScaling;
+    
+    managedTerminationProtection?: ManagedTerminationProtection | string;
+}
+export declare namespace AutoScalingGroupProviderUpdate {
+    
+    const filterSensitiveLog: (obj: AutoScalingGroupProviderUpdate) => any;
+}
+export interface UpdateCapacityProviderRequest {
+    
+    name: string | undefined;
+    
+    autoScalingGroupProvider: AutoScalingGroupProviderUpdate | undefined;
+}
+export declare namespace UpdateCapacityProviderRequest {
+    
+    const filterSensitiveLog: (obj: UpdateCapacityProviderRequest) => any;
+}
+export interface UpdateCapacityProviderResponse {
+    
+    capacityProvider?: CapacityProvider;
+}
+export declare namespace UpdateCapacityProviderResponse {
+    
+    const filterSensitiveLog: (obj: UpdateCapacityProviderResponse) => any;
+}
+export interface UpdateClusterRequest {
+    
+    cluster: string | undefined;
+    
+    settings?: ClusterSetting[];
+    
+    configuration?: ClusterConfiguration;
+}
+export declare namespace UpdateClusterRequest {
+    
+    const filterSensitiveLog: (obj: UpdateClusterRequest) => any;
+}
+export interface UpdateClusterResponse {
+    
+    cluster?: Cluster;
+}
+export declare namespace UpdateClusterResponse {
+    
+    const filterSensitiveLog: (obj: UpdateClusterResponse) => any;
+}
+export interface UpdateClusterSettingsRequest {
+    
+    cluster: string | undefined;
+    
+    settings: ClusterSetting[] | undefined;
+}
+export declare namespace UpdateClusterSettingsRequest {
+    
+    const filterSensitiveLog: (obj: UpdateClusterSettingsRequest) => any;
+}
+export interface UpdateClusterSettingsResponse {
+    
+    cluster?: Cluster;
+}
+export declare namespace UpdateClusterSettingsResponse {
+    
+    const filterSensitiveLog: (obj: UpdateClusterSettingsResponse) => any;
+}
+
+export declare class MissingVersionException extends __BaseException {
+    readonly name: "MissingVersionException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MissingVersionException, __BaseException>);
+}
+
+export declare class NoUpdateAvailableException extends __BaseException {
+    readonly name: "NoUpdateAvailableException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoUpdateAvailableException, __BaseException>);
+}
+export interface UpdateContainerAgentRequest {
+    
+    cluster?: string;
+    
+    containerInstance: string | undefined;
+}
+export declare namespace UpdateContainerAgentRequest {
+    
+    const filterSensitiveLog: (obj: UpdateContainerAgentRequest) => any;
+}
+export interface UpdateContainerAgentResponse {
+    
+    containerInstance?: ContainerInstance;
+}
+export declare namespace UpdateContainerAgentResponse {
+    
+    const filterSensitiveLog: (obj: UpdateContainerAgentResponse) => any;
+}
+export interface UpdateContainerInstancesStateRequest {
+    
+    cluster?: string;
+    
+    containerInstances: string[] | undefined;
+    
+    status: ContainerInstanceStatus | string | undefined;
+}
+export declare namespace UpdateContainerInstancesStateRequest {
+    
+    const filterSensitiveLog: (obj: UpdateContainerInstancesStateRequest) => any;
+}
+export interface UpdateContainerInstancesStateResponse {
+    
+    containerInstances?: ContainerInstance[];
+    
+    failures?: Failure[];
+}
+export declare namespace UpdateContainerInstancesStateResponse {
+    
+    const filterSensitiveLog: (obj: UpdateContainerInstancesStateResponse) => any;
+}
+export interface UpdateServiceRequest {
+    
+    cluster?: string;
+    
+    service: string | undefined;
+    
+    desiredCount?: number;
+    
+    taskDefinition?: string;
+    
+    capacityProviderStrategy?: CapacityProviderStrategyItem[];
+    
+    deploymentConfiguration?: DeploymentConfiguration;
+    
+    networkConfiguration?: NetworkConfiguration;
+    
+    placementConstraints?: PlacementConstraint[];
+    
+    placementStrategy?: PlacementStrategy[];
+    
+    platformVersion?: string;
+    
+    forceNewDeployment?: boolean;
+    
+    healthCheckGracePeriodSeconds?: number;
+    
+    enableExecuteCommand?: boolean;
+}
+export declare namespace UpdateServiceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateServiceRequest) => any;
+}
+export interface UpdateServiceResponse {
+    
+    service?: Service;
+}
+export declare namespace UpdateServiceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateServiceResponse) => any;
+}
+export interface UpdateServicePrimaryTaskSetRequest {
+    
+    cluster: string | undefined;
+    
+    service: string | undefined;
+    
+    primaryTaskSet: string | undefined;
+}
+export declare namespace UpdateServicePrimaryTaskSetRequest {
+    
+    const filterSensitiveLog: (obj: UpdateServicePrimaryTaskSetRequest) => any;
+}
+export interface UpdateServicePrimaryTaskSetResponse {
+    
+    taskSet?: TaskSet;
+}
+export declare namespace UpdateServicePrimaryTaskSetResponse {
+    
+    const filterSensitiveLog: (obj: UpdateServicePrimaryTaskSetResponse) => any;
+}
+export interface UpdateTaskSetRequest {
+    
+    cluster: string | undefined;
+    
+    service: string | undefined;
+    
+    taskSet: string | undefined;
+    
+    scale: Scale | undefined;
+}
+export declare namespace UpdateTaskSetRequest {
+    
+    const filterSensitiveLog: (obj: UpdateTaskSetRequest) => any;
+}
+export interface UpdateTaskSetResponse {
+    
+    taskSet?: TaskSet;
+}
+export declare namespace UpdateTaskSetResponse {
+    
+    const filterSensitiveLog: (obj: UpdateTaskSetResponse) => any;
+}