@aws-sdk/client-ecs 3.300.0 → 3.303.0

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

@@ -7,23 +7,27 @@ export declare class AccessDeniedException extends __BaseException {
     opts: __ExceptionOptionType<AccessDeniedException, __BaseException>
   );
 }
-export declare enum AgentUpdateStatus {
-  FAILED = "FAILED",
-  PENDING = "PENDING",
-  STAGED = "STAGED",
-  STAGING = "STAGING",
-  UPDATED = "UPDATED",
-  UPDATING = "UPDATING",
-}
+export declare const AgentUpdateStatus: {
+  readonly FAILED: "FAILED";
+  readonly PENDING: "PENDING";
+  readonly STAGED: "STAGED";
+  readonly STAGING: "STAGING";
+  readonly UPDATED: "UPDATED";
+  readonly UPDATING: "UPDATING";
+};
+export type AgentUpdateStatus =
+  (typeof AgentUpdateStatus)[keyof typeof AgentUpdateStatus];
 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 declare const ManagedScalingStatus: {
+  readonly DISABLED: "DISABLED";
+  readonly ENABLED: "ENABLED";
+};
+export type ManagedScalingStatus =
+  (typeof ManagedScalingStatus)[keyof typeof ManagedScalingStatus];
 export interface ManagedScaling {
   status?: ManagedScalingStatus | string;
   targetCapacity?: number;
@@ -31,10 +35,12 @@ export interface ManagedScaling {
   maximumScalingStepSize?: number;
   instanceWarmupPeriod?: number;
 }
-export declare enum ManagedTerminationProtection {
-  DISABLED = "DISABLED",
-  ENABLED = "ENABLED",
-}
+export declare const ManagedTerminationProtection: {
+  readonly DISABLED: "DISABLED";
+  readonly ENABLED: "ENABLED";
+};
+export type ManagedTerminationProtection =
+  (typeof ManagedTerminationProtection)[keyof typeof ManagedTerminationProtection];
 export interface AutoScalingGroupProvider {
   autoScalingGroupArn: string | undefined;
   managedScaling?: ManagedScaling;
@@ -49,18 +55,22 @@ export interface CreateCapacityProviderRequest {
   autoScalingGroupProvider: AutoScalingGroupProvider | undefined;
   tags?: Tag[];
 }
-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 declare const CapacityProviderStatus: {
+  readonly ACTIVE: "ACTIVE";
+  readonly INACTIVE: "INACTIVE";
+};
+export type CapacityProviderStatus =
+  (typeof CapacityProviderStatus)[keyof typeof CapacityProviderStatus];
+export declare const CapacityProviderUpdateStatus: {
+  readonly DELETE_COMPLETE: "DELETE_COMPLETE";
+  readonly DELETE_FAILED: "DELETE_FAILED";
+  readonly DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS";
+  readonly UPDATE_COMPLETE: "UPDATE_COMPLETE";
+  readonly UPDATE_FAILED: "UPDATE_FAILED";
+  readonly UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS";
+};
+export type CapacityProviderUpdateStatus =
+  (typeof CapacityProviderUpdateStatus)[keyof typeof CapacityProviderUpdateStatus];
 export interface CapacityProvider {
   capacityProviderArn?: string;
   name?: string;
@@ -106,11 +116,13 @@ export interface ExecuteCommandLogConfiguration {
   s3EncryptionEnabled?: boolean;
   s3KeyPrefix?: string;
 }
-export declare enum ExecuteCommandLogging {
-  DEFAULT = "DEFAULT",
-  NONE = "NONE",
-  OVERRIDE = "OVERRIDE",
-}
+export declare const ExecuteCommandLogging: {
+  readonly DEFAULT: "DEFAULT";
+  readonly NONE: "NONE";
+  readonly OVERRIDE: "OVERRIDE";
+};
+export type ExecuteCommandLogging =
+  (typeof ExecuteCommandLogging)[keyof typeof ExecuteCommandLogging];
 export interface ExecuteCommandConfiguration {
   kmsKeyId?: string;
   logging?: ExecuteCommandLogging | string;
@@ -127,9 +139,11 @@ export interface CapacityProviderStrategyItem {
 export interface ClusterServiceConnectDefaultsRequest {
   namespace: string | undefined;
 }
-export declare enum ClusterSettingName {
-  CONTAINER_INSIGHTS = "containerInsights",
-}
+export declare const ClusterSettingName: {
+  readonly CONTAINER_INSIGHTS: "containerInsights";
+};
+export type ClusterSettingName =
+  (typeof ClusterSettingName)[keyof typeof ClusterSettingName];
 export interface ClusterSetting {
   name?: ClusterSettingName | string;
   value?: string;
@@ -199,29 +213,34 @@ export interface DeploymentConfiguration {
   minimumHealthyPercent?: number;
   alarms?: DeploymentAlarms;
 }
-export declare enum DeploymentControllerType {
-  CODE_DEPLOY = "CODE_DEPLOY",
-  ECS = "ECS",
-  EXTERNAL = "EXTERNAL",
-}
+export declare const DeploymentControllerType: {
+  readonly CODE_DEPLOY: "CODE_DEPLOY";
+  readonly ECS: "ECS";
+  readonly EXTERNAL: "EXTERNAL";
+};
+export type DeploymentControllerType =
+  (typeof DeploymentControllerType)[keyof typeof DeploymentControllerType];
 export interface DeploymentController {
   type: DeploymentControllerType | string | undefined;
 }
-export declare enum LaunchType {
-  EC2 = "EC2",
-  EXTERNAL = "EXTERNAL",
-  FARGATE = "FARGATE",
-}
+export declare const LaunchType: {
+  readonly EC2: "EC2";
+  readonly EXTERNAL: "EXTERNAL";
+  readonly FARGATE: "FARGATE";
+};
+export type LaunchType = (typeof LaunchType)[keyof typeof LaunchType];
 export interface LoadBalancer {
   targetGroupArn?: string;
   loadBalancerName?: string;
   containerName?: string;
   containerPort?: number;
 }
-export declare enum AssignPublicIp {
-  DISABLED = "DISABLED",
-  ENABLED = "ENABLED",
-}
+export declare const AssignPublicIp: {
+  readonly DISABLED: "DISABLED";
+  readonly ENABLED: "ENABLED";
+};
+export type AssignPublicIp =
+  (typeof AssignPublicIp)[keyof typeof AssignPublicIp];
 export interface AwsVpcConfiguration {
   subnets: string[] | undefined;
   securityGroups?: string[];
@@ -230,42 +249,50 @@ export interface AwsVpcConfiguration {
 export interface NetworkConfiguration {
   awsvpcConfiguration?: AwsVpcConfiguration;
 }
-export declare enum PlacementConstraintType {
-  DISTINCT_INSTANCE = "distinctInstance",
-  MEMBER_OF = "memberOf",
-}
+export declare const PlacementConstraintType: {
+  readonly DISTINCT_INSTANCE: "distinctInstance";
+  readonly MEMBER_OF: "memberOf";
+};
+export type PlacementConstraintType =
+  (typeof PlacementConstraintType)[keyof typeof PlacementConstraintType];
 export interface PlacementConstraint {
   type?: PlacementConstraintType | string;
   expression?: string;
 }
-export declare enum PlacementStrategyType {
-  BINPACK = "binpack",
-  RANDOM = "random",
-  SPREAD = "spread",
-}
+export declare const PlacementStrategyType: {
+  readonly BINPACK: "binpack";
+  readonly RANDOM: "random";
+  readonly SPREAD: "spread";
+};
+export type PlacementStrategyType =
+  (typeof PlacementStrategyType)[keyof typeof PlacementStrategyType];
 export interface PlacementStrategy {
   type?: PlacementStrategyType | string;
   field?: string;
 }
-export declare enum PropagateTags {
-  NONE = "NONE",
-  SERVICE = "SERVICE",
-  TASK_DEFINITION = "TASK_DEFINITION",
-}
-export declare enum SchedulingStrategy {
-  DAEMON = "DAEMON",
-  REPLICA = "REPLICA",
-}
-export declare enum LogDriver {
-  AWSFIRELENS = "awsfirelens",
-  AWSLOGS = "awslogs",
-  FLUENTD = "fluentd",
-  GELF = "gelf",
-  JOURNALD = "journald",
-  JSON_FILE = "json-file",
-  SPLUNK = "splunk",
-  SYSLOG = "syslog",
-}
+export declare const PropagateTags: {
+  readonly NONE: "NONE";
+  readonly SERVICE: "SERVICE";
+  readonly TASK_DEFINITION: "TASK_DEFINITION";
+};
+export type PropagateTags = (typeof PropagateTags)[keyof typeof PropagateTags];
+export declare const SchedulingStrategy: {
+  readonly DAEMON: "DAEMON";
+  readonly REPLICA: "REPLICA";
+};
+export type SchedulingStrategy =
+  (typeof SchedulingStrategy)[keyof typeof SchedulingStrategy];
+export declare const LogDriver: {
+  readonly AWSFIRELENS: "awsfirelens";
+  readonly AWSLOGS: "awslogs";
+  readonly FLUENTD: "fluentd";
+  readonly GELF: "gelf";
+  readonly JOURNALD: "journald";
+  readonly JSON_FILE: "json-file";
+  readonly SPLUNK: "splunk";
+  readonly SYSLOG: "syslog";
+};
+export type LogDriver = (typeof LogDriver)[keyof typeof LogDriver];
 export interface Secret {
   name: string | undefined;
   valueFrom: string | undefined;
@@ -322,11 +349,13 @@ export interface CreateServiceRequest {
   enableExecuteCommand?: boolean;
   serviceConnectConfiguration?: ServiceConnectConfiguration;
 }
-export declare enum DeploymentRolloutState {
-  COMPLETED = "COMPLETED",
-  FAILED = "FAILED",
-  IN_PROGRESS = "IN_PROGRESS",
-}
+export declare const DeploymentRolloutState: {
+  readonly COMPLETED: "COMPLETED";
+  readonly FAILED: "FAILED";
+  readonly IN_PROGRESS: "IN_PROGRESS";
+};
+export type DeploymentRolloutState =
+  (typeof DeploymentRolloutState)[keyof typeof DeploymentRolloutState];
 export interface ServiceConnectServiceResource {
   discoveryName?: string;
   discoveryArn?: string;
@@ -356,17 +385,20 @@ export interface ServiceEvent {
   createdAt?: Date;
   message?: string;
 }
-export declare enum ScaleUnit {
-  PERCENT = "PERCENT",
-}
+export declare const ScaleUnit: {
+  readonly PERCENT: "PERCENT";
+};
+export type ScaleUnit = (typeof ScaleUnit)[keyof typeof ScaleUnit];
 export interface Scale {
   value?: number;
   unit?: ScaleUnit | string;
 }
-export declare enum StabilityStatus {
-  STABILIZING = "STABILIZING",
-  STEADY_STATE = "STEADY_STATE",
-}
+export declare const StabilityStatus: {
+  readonly STABILIZING: "STABILIZING";
+  readonly STEADY_STATE: "STEADY_STATE";
+};
+export type StabilityStatus =
+  (typeof StabilityStatus)[keyof typeof StabilityStatus];
 export interface TaskSet {
   id?: string;
   taskSetArn?: string;
@@ -492,13 +524,14 @@ export declare class ServiceNotFoundException extends __BaseException {
     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 declare const SettingName: {
+  readonly AWSVPC_TRUNKING: "awsvpcTrunking";
+  readonly CONTAINER_INSIGHTS: "containerInsights";
+  readonly CONTAINER_INSTANCE_LONG_ARN_FORMAT: "containerInstanceLongArnFormat";
+  readonly SERVICE_LONG_ARN_FORMAT: "serviceLongArnFormat";
+  readonly TASK_LONG_ARN_FORMAT: "taskLongArnFormat";
+};
+export type SettingName = (typeof SettingName)[keyof typeof SettingName];
 export interface DeleteAccountSettingRequest {
   name: SettingName | string | undefined;
   principalArn?: string;
@@ -511,9 +544,10 @@ export interface Setting {
 export interface DeleteAccountSettingResponse {
   setting?: Setting;
 }
-export declare enum TargetType {
-  CONTAINER_INSTANCE = "container-instance",
-}
+export declare const TargetType: {
+  readonly CONTAINER_INSTANCE: "container-instance";
+};
+export type TargetType = (typeof TargetType)[keyof typeof TargetType];
 export interface Attribute {
   name: string | undefined;
   value?: string;
@@ -589,24 +623,29 @@ export interface Failure {
   reason?: string;
   detail?: string;
 }
-export declare enum Compatibility {
-  EC2 = "EC2",
-  EXTERNAL = "EXTERNAL",
-  FARGATE = "FARGATE",
-}
-export declare enum ContainerCondition {
-  COMPLETE = "COMPLETE",
-  HEALTHY = "HEALTHY",
-  START = "START",
-  SUCCESS = "SUCCESS",
-}
+export declare const Compatibility: {
+  readonly EC2: "EC2";
+  readonly EXTERNAL: "EXTERNAL";
+  readonly FARGATE: "FARGATE";
+};
+export type Compatibility = (typeof Compatibility)[keyof typeof Compatibility];
+export declare const ContainerCondition: {
+  readonly COMPLETE: "COMPLETE";
+  readonly HEALTHY: "HEALTHY";
+  readonly START: "START";
+  readonly SUCCESS: "SUCCESS";
+};
+export type ContainerCondition =
+  (typeof ContainerCondition)[keyof typeof ContainerCondition];
 export interface ContainerDependency {
   containerName: string | undefined;
   condition: ContainerCondition | string | undefined;
 }
-export declare enum EnvironmentFileType {
-  S3 = "s3",
-}
+export declare const EnvironmentFileType: {
+  readonly S3: "s3";
+};
+export type EnvironmentFileType =
+  (typeof EnvironmentFileType)[keyof typeof EnvironmentFileType];
 export interface EnvironmentFile {
   value: string | undefined;
   type: EnvironmentFileType | string | undefined;
@@ -615,10 +654,12 @@ export interface HostEntry {
   hostname: string | undefined;
   ipAddress: string | undefined;
 }
-export declare enum FirelensConfigurationType {
-  FLUENTBIT = "fluentbit",
-  FLUENTD = "fluentd",
-}
+export declare const FirelensConfigurationType: {
+  readonly FLUENTBIT: "fluentbit";
+  readonly FLUENTD: "fluentd";
+};
+export type FirelensConfigurationType =
+  (typeof FirelensConfigurationType)[keyof typeof FirelensConfigurationType];
 export interface FirelensConfiguration {
   type: FirelensConfigurationType | string | undefined;
   options?: Record<string, string>;
@@ -634,11 +675,13 @@ export interface KernelCapabilities {
   add?: string[];
   drop?: string[];
 }
-export declare enum DeviceCgroupPermission {
-  MKNOD = "mknod",
-  READ = "read",
-  WRITE = "write",
-}
+export declare const DeviceCgroupPermission: {
+  readonly MKNOD: "mknod";
+  readonly READ: "read";
+  readonly WRITE: "write";
+};
+export type DeviceCgroupPermission =
+  (typeof DeviceCgroupPermission)[keyof typeof DeviceCgroupPermission];
 export interface Device {
   hostPath: string | undefined;
   containerPath?: string;
@@ -663,15 +706,19 @@ export interface MountPoint {
   containerPath?: string;
   readOnly?: boolean;
 }
-export declare enum ApplicationProtocol {
-  GRPC = "grpc",
-  HTTP = "http",
-  HTTP2 = "http2",
-}
-export declare enum TransportProtocol {
-  TCP = "tcp",
-  UDP = "udp",
-}
+export declare const ApplicationProtocol: {
+  readonly GRPC: "grpc";
+  readonly HTTP: "http";
+  readonly HTTP2: "http2";
+};
+export type ApplicationProtocol =
+  (typeof ApplicationProtocol)[keyof typeof ApplicationProtocol];
+export declare const TransportProtocol: {
+  readonly TCP: "tcp";
+  readonly UDP: "udp";
+};
+export type TransportProtocol =
+  (typeof TransportProtocol)[keyof typeof TransportProtocol];
 export interface PortMapping {
   containerPort?: number;
   hostPort?: number;
@@ -683,10 +730,11 @@ export interface PortMapping {
 export interface RepositoryCredentials {
   credentialsParameter: string | undefined;
 }
-export declare enum ResourceType {
-  GPU = "GPU",
-  INFERENCE_ACCELERATOR = "InferenceAccelerator",
-}
+export declare const ResourceType: {
+  readonly GPU: "GPU";
+  readonly INFERENCE_ACCELERATOR: "InferenceAccelerator";
+};
+export type ResourceType = (typeof ResourceType)[keyof typeof ResourceType];
 export interface ResourceRequirement {
   value: string | undefined;
   type: ResourceType | string | undefined;
@@ -695,23 +743,24 @@ export interface SystemControl {
   namespace?: string;
   value?: string;
 }
-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 declare const UlimitName: {
+  readonly CORE: "core";
+  readonly CPU: "cpu";
+  readonly DATA: "data";
+  readonly FSIZE: "fsize";
+  readonly LOCKS: "locks";
+  readonly MEMLOCK: "memlock";
+  readonly MSGQUEUE: "msgqueue";
+  readonly NICE: "nice";
+  readonly NOFILE: "nofile";
+  readonly NPROC: "nproc";
+  readonly RSS: "rss";
+  readonly RTPRIO: "rtprio";
+  readonly RTTIME: "rttime";
+  readonly SIGPENDING: "sigpending";
+  readonly STACK: "stack";
+};
+export type UlimitName = (typeof UlimitName)[keyof typeof UlimitName];
 export interface Ulimit {
   name: UlimitName | string | undefined;
   softLimit: number | undefined;
@@ -769,63 +818,76 @@ export interface InferenceAccelerator {
   deviceName: string | undefined;
   deviceType: string | undefined;
 }
-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 declare const IpcMode: {
+  readonly HOST: "host";
+  readonly NONE: "none";
+  readonly TASK: "task";
+};
+export type IpcMode = (typeof IpcMode)[keyof typeof IpcMode];
+export declare const NetworkMode: {
+  readonly AWSVPC: "awsvpc";
+  readonly BRIDGE: "bridge";
+  readonly HOST: "host";
+  readonly NONE: "none";
+};
+export type NetworkMode = (typeof NetworkMode)[keyof typeof NetworkMode];
+export declare const PidMode: {
+  readonly HOST: "host";
+  readonly TASK: "task";
+};
+export type PidMode = (typeof PidMode)[keyof typeof PidMode];
+export declare const TaskDefinitionPlacementConstraintType: {
+  readonly MEMBER_OF: "memberOf";
+};
+export type TaskDefinitionPlacementConstraintType =
+  (typeof TaskDefinitionPlacementConstraintType)[keyof typeof TaskDefinitionPlacementConstraintType];
 export interface TaskDefinitionPlacementConstraint {
   type?: TaskDefinitionPlacementConstraintType | string;
   expression?: string;
 }
-export declare enum ProxyConfigurationType {
-  APPMESH = "APPMESH",
-}
+export declare const ProxyConfigurationType: {
+  readonly APPMESH: "APPMESH";
+};
+export type ProxyConfigurationType =
+  (typeof ProxyConfigurationType)[keyof typeof ProxyConfigurationType];
 export interface ProxyConfiguration {
   type?: ProxyConfigurationType | string;
   containerName: string | undefined;
   properties?: KeyValuePair[];
 }
-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 declare const CPUArchitecture: {
+  readonly ARM64: "ARM64";
+  readonly X86_64: "X86_64";
+};
+export type CPUArchitecture =
+  (typeof CPUArchitecture)[keyof typeof CPUArchitecture];
+export declare const OSFamily: {
+  readonly LINUX: "LINUX";
+  readonly WINDOWS_SERVER_2004_CORE: "WINDOWS_SERVER_2004_CORE";
+  readonly WINDOWS_SERVER_2016_FULL: "WINDOWS_SERVER_2016_FULL";
+  readonly WINDOWS_SERVER_2019_CORE: "WINDOWS_SERVER_2019_CORE";
+  readonly WINDOWS_SERVER_2019_FULL: "WINDOWS_SERVER_2019_FULL";
+  readonly WINDOWS_SERVER_2022_CORE: "WINDOWS_SERVER_2022_CORE";
+  readonly WINDOWS_SERVER_2022_FULL: "WINDOWS_SERVER_2022_FULL";
+  readonly WINDOWS_SERVER_20H2_CORE: "WINDOWS_SERVER_20H2_CORE";
+};
+export type OSFamily = (typeof OSFamily)[keyof typeof OSFamily];
 export interface RuntimePlatform {
   cpuArchitecture?: CPUArchitecture | string;
   operatingSystemFamily?: OSFamily | string;
 }
-export declare enum TaskDefinitionStatus {
-  ACTIVE = "ACTIVE",
-  DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
-  INACTIVE = "INACTIVE",
-}
-export declare enum Scope {
-  SHARED = "shared",
-  TASK = "task",
-}
+export declare const TaskDefinitionStatus: {
+  readonly ACTIVE: "ACTIVE";
+  readonly DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS";
+  readonly INACTIVE: "INACTIVE";
+};
+export type TaskDefinitionStatus =
+  (typeof TaskDefinitionStatus)[keyof typeof TaskDefinitionStatus];
+export declare const Scope: {
+  readonly SHARED: "shared";
+  readonly TASK: "task";
+};
+export type Scope = (typeof Scope)[keyof typeof Scope];
 export interface DockerVolumeConfiguration {
   scope?: Scope | string;
   autoprovision?: boolean;
@@ -833,18 +895,22 @@ export interface DockerVolumeConfiguration {
   driverOpts?: Record<string, string>;
   labels?: Record<string, string>;
 }
-export declare enum EFSAuthorizationConfigIAM {
-  DISABLED = "DISABLED",
-  ENABLED = "ENABLED",
-}
+export declare const EFSAuthorizationConfigIAM: {
+  readonly DISABLED: "DISABLED";
+  readonly ENABLED: "ENABLED";
+};
+export type EFSAuthorizationConfigIAM =
+  (typeof EFSAuthorizationConfigIAM)[keyof typeof EFSAuthorizationConfigIAM];
 export interface EFSAuthorizationConfig {
   accessPointId?: string;
   iam?: EFSAuthorizationConfigIAM | string;
 }
-export declare enum EFSTransitEncryption {
-  DISABLED = "DISABLED",
-  ENABLED = "ENABLED",
-}
+export declare const EFSTransitEncryption: {
+  readonly DISABLED: "DISABLED";
+  readonly ENABLED: "ENABLED";
+};
+export type EFSTransitEncryption =
+  (typeof EFSTransitEncryption)[keyof typeof EFSTransitEncryption];
 export interface EFSVolumeConfiguration {
   fileSystemId: string | undefined;
   rootDirectory?: string;
@@ -922,15 +988,19 @@ export interface DeregisterContainerInstanceRequest {
   containerInstance: string | undefined;
   force?: boolean;
 }
-export declare enum InstanceHealthCheckState {
-  IMPAIRED = "IMPAIRED",
-  INITIALIZING = "INITIALIZING",
-  INSUFFICIENT_DATA = "INSUFFICIENT_DATA",
-  OK = "OK",
-}
-export declare enum InstanceHealthCheckType {
-  CONTAINER_RUNTIME = "CONTAINER_RUNTIME",
-}
+export declare const InstanceHealthCheckState: {
+  readonly IMPAIRED: "IMPAIRED";
+  readonly INITIALIZING: "INITIALIZING";
+  readonly INSUFFICIENT_DATA: "INSUFFICIENT_DATA";
+  readonly OK: "OK";
+};
+export type InstanceHealthCheckState =
+  (typeof InstanceHealthCheckState)[keyof typeof InstanceHealthCheckState];
+export declare const InstanceHealthCheckType: {
+  readonly CONTAINER_RUNTIME: "CONTAINER_RUNTIME";
+};
+export type InstanceHealthCheckType =
+  (typeof InstanceHealthCheckType)[keyof typeof InstanceHealthCheckType];
 export interface InstanceHealthCheckResult {
   type?: InstanceHealthCheckType | string;
   status?: InstanceHealthCheckState | string;
@@ -983,9 +1053,11 @@ export interface DeregisterTaskDefinitionRequest {
 export interface DeregisterTaskDefinitionResponse {
   taskDefinition?: TaskDefinition;
 }
-export declare enum CapacityProviderField {
-  TAGS = "TAGS",
-}
+export declare const CapacityProviderField: {
+  readonly TAGS: "TAGS";
+};
+export type CapacityProviderField =
+  (typeof CapacityProviderField)[keyof typeof CapacityProviderField];
 export interface DescribeCapacityProvidersRequest {
   capacityProviders?: string[];
   include?: (CapacityProviderField | string)[];
@@ -997,13 +1069,14 @@ export interface DescribeCapacityProvidersResponse {
   failures?: Failure[];
   nextToken?: string;
 }
-export declare enum ClusterField {
-  ATTACHMENTS = "ATTACHMENTS",
-  CONFIGURATIONS = "CONFIGURATIONS",
-  SETTINGS = "SETTINGS",
-  STATISTICS = "STATISTICS",
-  TAGS = "TAGS",
-}
+export declare const ClusterField: {
+  readonly ATTACHMENTS: "ATTACHMENTS";
+  readonly CONFIGURATIONS: "CONFIGURATIONS";
+  readonly SETTINGS: "SETTINGS";
+  readonly STATISTICS: "STATISTICS";
+  readonly TAGS: "TAGS";
+};
+export type ClusterField = (typeof ClusterField)[keyof typeof ClusterField];
 export interface DescribeClustersRequest {
   clusters?: string[];
   include?: (ClusterField | string)[];
@@ -1012,10 +1085,12 @@ export interface DescribeClustersResponse {
   clusters?: Cluster[];
   failures?: Failure[];
 }
-export declare enum ContainerInstanceField {
-  CONTAINER_INSTANCE_HEALTH = "CONTAINER_INSTANCE_HEALTH",
-  TAGS = "TAGS",
-}
+export declare const ContainerInstanceField: {
+  readonly CONTAINER_INSTANCE_HEALTH: "CONTAINER_INSTANCE_HEALTH";
+  readonly TAGS: "TAGS";
+};
+export type ContainerInstanceField =
+  (typeof ContainerInstanceField)[keyof typeof ContainerInstanceField];
 export interface DescribeContainerInstancesRequest {
   cluster?: string;
   containerInstances: string[] | undefined;
@@ -1025,9 +1100,10 @@ export interface DescribeContainerInstancesResponse {
   containerInstances?: ContainerInstance[];
   failures?: Failure[];
 }
-export declare enum ServiceField {
-  TAGS = "TAGS",
-}
+export declare const ServiceField: {
+  readonly TAGS: "TAGS";
+};
+export type ServiceField = (typeof ServiceField)[keyof typeof ServiceField];
 export interface DescribeServicesRequest {
   cluster?: string;
   services: string[] | undefined;
@@ -1037,9 +1113,11 @@ export interface DescribeServicesResponse {
   services?: Service[];
   failures?: Failure[];
 }
-export declare enum TaskDefinitionField {
-  TAGS = "TAGS",
-}
+export declare const TaskDefinitionField: {
+  readonly TAGS: "TAGS";
+};
+export type TaskDefinitionField =
+  (typeof TaskDefinitionField)[keyof typeof TaskDefinitionField];
 export interface DescribeTaskDefinitionRequest {
   taskDefinition: string | undefined;
   include?: (TaskDefinitionField | string)[];
@@ -1048,26 +1126,31 @@ export interface DescribeTaskDefinitionResponse {
   taskDefinition?: TaskDefinition;
   tags?: Tag[];
 }
-export declare enum TaskField {
-  TAGS = "TAGS",
-}
+export declare const TaskField: {
+  readonly TAGS: "TAGS";
+};
+export type TaskField = (typeof TaskField)[keyof typeof TaskField];
 export interface DescribeTasksRequest {
   cluster?: string;
   tasks: string[] | undefined;
   include?: (TaskField | string)[];
 }
-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 declare const Connectivity: {
+  readonly CONNECTED: "CONNECTED";
+  readonly DISCONNECTED: "DISCONNECTED";
+};
+export type Connectivity = (typeof Connectivity)[keyof typeof Connectivity];
+export declare const HealthStatus: {
+  readonly HEALTHY: "HEALTHY";
+  readonly UNHEALTHY: "UNHEALTHY";
+  readonly UNKNOWN: "UNKNOWN";
+};
+export type HealthStatus = (typeof HealthStatus)[keyof typeof HealthStatus];
+export declare const ManagedAgentName: {
+  readonly ExecuteCommandAgent: "ExecuteCommandAgent";
+};
+export type ManagedAgentName =
+  (typeof ManagedAgentName)[keyof typeof ManagedAgentName];
 export interface ManagedAgent {
   lastStartedAt?: Date;
   name?: ManagedAgentName | string;
@@ -1129,14 +1212,15 @@ export interface TaskOverride {
   taskRoleArn?: string;
   ephemeralStorage?: EphemeralStorage;
 }
-export declare enum TaskStopCode {
-  ESSENTIAL_CONTAINER_EXITED = "EssentialContainerExited",
-  SERVICE_SCHEDULER_INITIATED = "ServiceSchedulerInitiated",
-  SPOT_INTERRUPTION = "SpotInterruption",
-  TASK_FAILED_TO_START = "TaskFailedToStart",
-  TERMINATION_NOTICE = "TerminationNotice",
-  USER_INITIATED = "UserInitiated",
-}
+export declare const TaskStopCode: {
+  readonly ESSENTIAL_CONTAINER_EXITED: "EssentialContainerExited";
+  readonly SERVICE_SCHEDULER_INITIATED: "ServiceSchedulerInitiated";
+  readonly SPOT_INTERRUPTION: "SpotInterruption";
+  readonly TASK_FAILED_TO_START: "TaskFailedToStart";
+  readonly TERMINATION_NOTICE: "TerminationNotice";
+  readonly USER_INITIATED: "UserInitiated";
+};
+export type TaskStopCode = (typeof TaskStopCode)[keyof typeof TaskStopCode];
 export interface Task {
   attachments?: Attachment[];
   attributes?: Attribute[];
@@ -1179,9 +1263,10 @@ export interface DescribeTasksResponse {
   tasks?: Task[];
   failures?: Failure[];
 }
-export declare enum TaskSetField {
-  TAGS = "TAGS",
-}
+export declare const TaskSetField: {
+  readonly TAGS: "TAGS";
+};
+export type TaskSetField = (typeof TaskSetField)[keyof typeof TaskSetField];
 export interface DescribeTaskSetsRequest {
   cluster: string | undefined;
   service: string | undefined;
@@ -1280,13 +1365,15 @@ export interface ListClustersResponse {
   clusterArns?: string[];
   nextToken?: string;
 }
-export declare enum ContainerInstanceStatus {
-  ACTIVE = "ACTIVE",
-  DEREGISTERING = "DEREGISTERING",
-  DRAINING = "DRAINING",
-  REGISTERING = "REGISTERING",
-  REGISTRATION_FAILED = "REGISTRATION_FAILED",
-}
+export declare const ContainerInstanceStatus: {
+  readonly ACTIVE: "ACTIVE";
+  readonly DEREGISTERING: "DEREGISTERING";
+  readonly DRAINING: "DRAINING";
+  readonly REGISTERING: "REGISTERING";
+  readonly REGISTRATION_FAILED: "REGISTRATION_FAILED";
+};
+export type ContainerInstanceStatus =
+  (typeof ContainerInstanceStatus)[keyof typeof ContainerInstanceStatus];
 export interface ListContainerInstancesRequest {
   cluster?: string;
   filter?: string;
@@ -1324,11 +1411,13 @@ export interface ListTagsForResourceRequest {
 export interface ListTagsForResourceResponse {
   tags?: Tag[];
 }
-export declare enum TaskDefinitionFamilyStatus {
-  ACTIVE = "ACTIVE",
-  ALL = "ALL",
-  INACTIVE = "INACTIVE",
-}
+export declare const TaskDefinitionFamilyStatus: {
+  readonly ACTIVE: "ACTIVE";
+  readonly ALL: "ALL";
+  readonly INACTIVE: "INACTIVE";
+};
+export type TaskDefinitionFamilyStatus =
+  (typeof TaskDefinitionFamilyStatus)[keyof typeof TaskDefinitionFamilyStatus];
 export interface ListTaskDefinitionFamiliesRequest {
   familyPrefix?: string;
   status?: TaskDefinitionFamilyStatus | string;
@@ -1339,10 +1428,11 @@ export interface ListTaskDefinitionFamiliesResponse {
   families?: string[];
   nextToken?: string;
 }
-export declare enum SortOrder {
-  ASC = "ASC",
-  DESC = "DESC",
-}
+export declare const SortOrder: {
+  readonly ASC: "ASC";
+  readonly DESC: "DESC";
+};
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder];
 export interface ListTaskDefinitionsRequest {
   familyPrefix?: string;
   status?: TaskDefinitionStatus | string;
@@ -1354,11 +1444,12 @@ export interface ListTaskDefinitionsResponse {
   taskDefinitionArns?: string[];
   nextToken?: string;
 }
-export declare enum DesiredStatus {
-  PENDING = "PENDING",
-  RUNNING = "RUNNING",
-  STOPPED = "STOPPED",
-}
+export declare const DesiredStatus: {
+  readonly PENDING: "PENDING";
+  readonly RUNNING: "RUNNING";
+  readonly STOPPED: "STOPPED";
+};
+export type DesiredStatus = (typeof DesiredStatus)[keyof typeof DesiredStatus];
 export interface ListTasksRequest {
   cluster?: string;
   containerInstance?: string;
@@ -1421,9 +1512,11 @@ export declare class ResourceInUseException extends __BaseException {
     opts: __ExceptionOptionType<ResourceInUseException, __BaseException>
   );
 }
-export declare enum PlatformDeviceType {
-  GPU = "GPU",
-}
+export declare const PlatformDeviceType: {
+  readonly GPU: "GPU";
+};
+export type PlatformDeviceType =
+  (typeof PlatformDeviceType)[keyof typeof PlatformDeviceType];
 export interface PlatformDevice {
   id: string | undefined;
   type: PlatformDeviceType | string | undefined;