export declare const CapacityProviderAutoScalingGroupProviderManagedDraining: {
    readonly Disabled: "DISABLED";
    readonly Enabled: "ENABLED";
};
/**
 * The managed draining option for the Auto Scaling group capacity provider. When you enable this, Amazon ECS manages and gracefully drains the EC2 container instances that are in the Auto Scaling group capacity provider.
 */
export type CapacityProviderAutoScalingGroupProviderManagedDraining = (typeof CapacityProviderAutoScalingGroupProviderManagedDraining)[keyof typeof CapacityProviderAutoScalingGroupProviderManagedDraining];
export declare const CapacityProviderAutoScalingGroupProviderManagedTerminationProtection: {
    readonly Disabled: "DISABLED";
    readonly Enabled: "ENABLED";
};
/**
 * The managed termination protection setting to use for the Auto Scaling group capacity provider. This determines whether the Auto Scaling group has managed termination protection. The default is off.
 *
 * > When using managed termination protection, managed scaling must also be used otherwise managed termination protection doesn't work.
 *
 * When managed termination protection is on, Amazon ECS prevents the Amazon EC2 instances in an Auto Scaling group that contain tasks from being terminated during a scale-in action. The Auto Scaling group and each instance in the Auto Scaling group must have instance protection from scale-in actions on as well. For more information, see [Instance Protection](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html#instance-protection) in the *AWS Auto Scaling User Guide* .
 *
 * When managed termination protection is off, your Amazon EC2 instances aren't protected from termination when the Auto Scaling group scales in.
 */
export type CapacityProviderAutoScalingGroupProviderManagedTerminationProtection = (typeof CapacityProviderAutoScalingGroupProviderManagedTerminationProtection)[keyof typeof CapacityProviderAutoScalingGroupProviderManagedTerminationProtection];
export declare const CapacityProviderManagedScalingStatus: {
    readonly Disabled: "DISABLED";
    readonly Enabled: "ENABLED";
};
/**
 * Determines whether to use managed scaling for the capacity provider.
 */
export type CapacityProviderManagedScalingStatus = (typeof CapacityProviderManagedScalingStatus)[keyof typeof CapacityProviderManagedScalingStatus];
export declare const ClusterCapacityProviderAssociationsCapacityProvider: {
    readonly Fargate: "FARGATE";
    readonly FargateSpot: "FARGATE_SPOT";
};
/**
 * If using ec2 auto-scaling, the name of the associated capacity provider. Otherwise FARGATE, FARGATE_SPOT.
 */
export type ClusterCapacityProviderAssociationsCapacityProvider = (typeof ClusterCapacityProviderAssociationsCapacityProvider)[keyof typeof ClusterCapacityProviderAssociationsCapacityProvider];
export declare const ClusterCapacityProviderAssociationsCapacityProvider0: {
    readonly Fargate: "FARGATE";
    readonly FargateSpot: "FARGATE_SPOT";
};
/**
 * If using ec2 auto-scaling, the name of the associated capacity provider. Otherwise FARGATE, FARGATE_SPOT.
 */
export type ClusterCapacityProviderAssociationsCapacityProvider0 = (typeof ClusterCapacityProviderAssociationsCapacityProvider0)[keyof typeof ClusterCapacityProviderAssociationsCapacityProvider0];
export declare const ServiceAvailabilityZoneRebalancing: {
    readonly Enabled: "ENABLED";
    readonly Disabled: "DISABLED";
};
/**
 * Indicates whether to use Availability Zone rebalancing for the service.
 *  For more information, see [Balancing an Amazon ECS service across Availability Zones](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-rebalancing.html) in the *Amazon Elastic Container Service Developer Guide*.
 */
export type ServiceAvailabilityZoneRebalancing = (typeof ServiceAvailabilityZoneRebalancing)[keyof typeof ServiceAvailabilityZoneRebalancing];
export declare const ServiceAwsVpcConfigurationAssignPublicIp: {
    readonly Disabled: "DISABLED";
    readonly Enabled: "ENABLED";
};
/**
 * Whether the task's elastic network interface receives a public IP address.
 *  Consider the following when you set this value:
 *   +  When you use ``create-service`` or ``update-service``, the default is ``DISABLED``.
 *   +  When the service ``deploymentController`` is ``ECS``, the value must be ``DISABLED``.
 */
export type ServiceAwsVpcConfigurationAssignPublicIp = (typeof ServiceAwsVpcConfigurationAssignPublicIp)[keyof typeof ServiceAwsVpcConfigurationAssignPublicIp];
export declare const ServiceDeploymentControllerType: {
    readonly CodeDeploy: "CODE_DEPLOY";
    readonly Ecs: "ECS";
    readonly External: "EXTERNAL";
};
/**
 * The deployment controller type to use. There are three deployment controller types available:
 *   + ECS The rolling update (ECS) deployment type involves replacing the current running version of the container with the latest version. The number of containers Amazon ECS adds or removes from the service during a rolling update is controlled by adjusting the minimum and maximum number of healthy tasks allowed during a service deployment, as specified in the DeploymentConfiguration. + CODE_DEPLOY The blue/green (CODE_DEPLOY) deployment type uses the blue/green deployment model powered by , which allows you to verify a new deployment of a service before sending production traffic to it. + EXTERNAL The external (EXTERNAL) deployment type enables you to use any third-party deployment controller for full control over the deployment process for an Amazon ECS service.
 */
export type ServiceDeploymentControllerType = (typeof ServiceDeploymentControllerType)[keyof typeof ServiceDeploymentControllerType];
export declare const ServiceEbsTagSpecificationPropagateTags: {
    readonly Service: "SERVICE";
    readonly TaskDefinition: "TASK_DEFINITION";
};
/**
 * Determines whether to propagate the tags from the task definition to
 * the Amazon EBS volume. Tags can only propagate to a ``SERVICE`` specified in
 * ``ServiceVolumeConfiguration``. If no value is specified, the tags aren't
 * propagated.
 */
export type ServiceEbsTagSpecificationPropagateTags = (typeof ServiceEbsTagSpecificationPropagateTags)[keyof typeof ServiceEbsTagSpecificationPropagateTags];
export declare const ServiceLaunchType: {
    readonly Ec2: "EC2";
    readonly Fargate: "FARGATE";
    readonly External: "EXTERNAL";
};
/**
 * The launch type on which to run your service. For more information, see [Amazon ECS Launch Types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) in the *Amazon Elastic Container Service Developer Guide*.
 */
export type ServiceLaunchType = (typeof ServiceLaunchType)[keyof typeof ServiceLaunchType];
export declare const ServicePlacementConstraintType: {
    readonly DistinctInstance: "distinctInstance";
    readonly MemberOf: "memberOf";
};
/**
 * The type of constraint. Use ``distinctInstance`` to ensure that each task in a particular group is running on a different container instance. Use ``memberOf`` to restrict the selection to a group of valid candidates.
 */
export type ServicePlacementConstraintType = (typeof ServicePlacementConstraintType)[keyof typeof ServicePlacementConstraintType];
export declare const ServicePlacementStrategyType: {
    readonly Binpack: "binpack";
    readonly Random: "random";
    readonly Spread: "spread";
};
/**
 * The type of placement strategy. The ``random`` placement strategy randomly places tasks on available candidates. The ``spread`` placement strategy spreads placement across available candidates evenly based on the ``field`` parameter. The ``binpack`` strategy places tasks on available candidates that have the least available amount of the resource that's specified with the ``field`` parameter. For example, if you binpack on memory, a task is placed on the instance with the least amount of remaining memory but still enough to run the task.
 */
export type ServicePlacementStrategyType = (typeof ServicePlacementStrategyType)[keyof typeof ServicePlacementStrategyType];
export declare const ServicePropagateTags: {
    readonly Service: "SERVICE";
    readonly TaskDefinition: "TASK_DEFINITION";
};
/**
 * Specifies whether to propagate the tags from the task definition to the task. If no value is specified, the tags aren't propagated. Tags can only be propagated to the task during task creation. To add tags to a task after task creation, use the [TagResource](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TagResource.html) API action.
 *  You must set this to a value other than ``NONE`` when you use Cost Explorer. For more information, see [Amazon ECS usage reports](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/usage-reports.html) in the *Amazon Elastic Container Service Developer Guide*.
 *  The default is ``NONE``.
 */
export type ServicePropagateTags = (typeof ServicePropagateTags)[keyof typeof ServicePropagateTags];
export declare const ServiceSchedulingStrategy: {
    readonly Daemon: "DAEMON";
    readonly Replica: "REPLICA";
};
/**
 * The scheduling strategy to use for the service. For more information, see [Services](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html).
 *  There are two service scheduler strategies available:
 *   +   ``REPLICA``-The replica scheduling strategy places and maintains the desired number of tasks across your cluster. By default, the service scheduler spreads tasks across Availability Zones. You can use task placement strategies and constraints to customize task placement decisions. This scheduler strategy is required if the service uses the ``CODE_DEPLOY`` or ``EXTERNAL`` deployment controller types.
 *   +   ``DAEMON``-The daemon scheduling strategy deploys exactly one task on each active container instance that meets all of the task placement constraints that you specify in your cluster. The service scheduler also evaluates the task placement constraints for running tasks and will stop tasks that don't meet the placement constraints. When you're using this strategy, you don't need to specify a desired number of tasks, a task placement strategy, or use Service Auto Scaling policies.
 *   Tasks using the Fargate launch type or the ``CODE_DEPLOY`` or ``EXTERNAL`` deployment controller types don't support the ``DAEMON`` scheduling strategy.
 */
export type ServiceSchedulingStrategy = (typeof ServiceSchedulingStrategy)[keyof typeof ServiceSchedulingStrategy];
export declare const TaskDefinitionAuthorizationConfigIam: {
    readonly Enabled: "ENABLED";
    readonly Disabled: "DISABLED";
};
/**
 * Determines whether to use the Amazon ECS task role defined in a task definition when mounting the Amazon EFS file system. If it is turned on, transit encryption must be turned on in the ``EFSVolumeConfiguration``. If this parameter is omitted, the default value of ``DISABLED`` is used. For more information, see [Using Amazon EFS access points](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints) in the *Amazon Elastic Container Service Developer Guide*.
 */
export type TaskDefinitionAuthorizationConfigIam = (typeof TaskDefinitionAuthorizationConfigIam)[keyof typeof TaskDefinitionAuthorizationConfigIam];
export declare const TaskDefinitionContainerDefinitionVersionConsistency: {
    readonly Enabled: "enabled";
    readonly Disabled: "disabled";
};
/**
 * Specifies whether Amazon ECS will resolve the container image tag provided in the container definition to an image digest. By default, the value is ``enabled``. If you set the value for a container as ``disabled``, Amazon ECS will not resolve the provided container image tag to a digest and will use the original image URI specified in the container definition for deployment. For more information about container image resolution, see [Container image resolution](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html#deployment-container-image-stability) in the *Amazon ECS Developer Guide*.
 */
export type TaskDefinitionContainerDefinitionVersionConsistency = (typeof TaskDefinitionContainerDefinitionVersionConsistency)[keyof typeof TaskDefinitionContainerDefinitionVersionConsistency];
export declare const TaskDefinitionEfsVolumeConfigurationTransitEncryption: {
    readonly Enabled: "ENABLED";
    readonly Disabled: "DISABLED";
};
/**
 * Determines whether to use encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be turned on if Amazon EFS IAM authorization is used. If this parameter is omitted, the default value of ``DISABLED`` is used. For more information, see [Encrypting data in transit](https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html) in the *Amazon Elastic File System User Guide*.
 */
export type TaskDefinitionEfsVolumeConfigurationTransitEncryption = (typeof TaskDefinitionEfsVolumeConfigurationTransitEncryption)[keyof typeof TaskDefinitionEfsVolumeConfigurationTransitEncryption];
export declare const TaskDefinitionPortMappingAppProtocol: {
    readonly Http: "http";
    readonly Http2: "http2";
    readonly Grpc: "grpc";
};
/**
 * The application protocol that's used for the port mapping. This parameter only applies to Service Connect. We recommend that you set this parameter to be consistent with the protocol that your application uses. If you set this parameter, Amazon ECS adds protocol-specific connection handling to the Service Connect proxy. If you set this parameter, Amazon ECS adds protocol-specific telemetry in the Amazon ECS console and CloudWatch.
 *  If you don't set a value for this parameter, then TCP is used. However, Amazon ECS doesn't add protocol-specific telemetry for TCP.
 *   ``appProtocol`` is immutable in a Service Connect service. Updating this field requires a service deletion and redeployment.
 *  Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
 */
export type TaskDefinitionPortMappingAppProtocol = (typeof TaskDefinitionPortMappingAppProtocol)[keyof typeof TaskDefinitionPortMappingAppProtocol];
export declare const TaskSetAwsVpcConfigurationAssignPublicIp: {
    readonly Disabled: "DISABLED";
    readonly Enabled: "ENABLED";
};
/**
 * Whether the task's elastic network interface receives a public IP address. The default value is DISABLED.
 */
export type TaskSetAwsVpcConfigurationAssignPublicIp = (typeof TaskSetAwsVpcConfigurationAssignPublicIp)[keyof typeof TaskSetAwsVpcConfigurationAssignPublicIp];
export declare const TaskSetLaunchType: {
    readonly Ec2: "EC2";
    readonly Fargate: "FARGATE";
};
/**
 * The launch type that new tasks in the task set will use. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html in the Amazon Elastic Container Service Developer Guide.
 */
export type TaskSetLaunchType = (typeof TaskSetLaunchType)[keyof typeof TaskSetLaunchType];
export declare const TaskSetScaleUnit: {
    readonly Percent: "PERCENT";
};
/**
 * The unit of measure for the scale value.
 */
export type TaskSetScaleUnit = (typeof TaskSetScaleUnit)[keyof typeof TaskSetScaleUnit];
