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 CapacityProviderCapacityReservationRequestReservationPreference: {
    readonly ReservationsOnly: "RESERVATIONS_ONLY";
    readonly ReservationsFirst: "RESERVATIONS_FIRST";
    readonly ReservationsExcluded: "RESERVATIONS_EXCLUDED";
};
export type CapacityProviderCapacityReservationRequestReservationPreference = (typeof CapacityProviderCapacityReservationRequestReservationPreference)[keyof typeof CapacityProviderCapacityReservationRequestReservationPreference];
export declare const CapacityProviderInstanceLaunchTemplateCapacityOptionType: {
    readonly OnDemand: "ON_DEMAND";
    readonly Spot: "SPOT";
    readonly Reserved: "RESERVED";
};
/**
 * The capacity option type. This determines whether Amazon ECS launches On-Demand or Spot Instances for your managed instance capacity provider.
 *
 * Valid values are:
 *
 * - `ON_DEMAND` - Launches standard On-Demand Instances. On-Demand Instances provide predictable pricing and availability.
 * - `SPOT` - Launches Spot Instances that use spare Amazon EC2 capacity at reduced cost. Spot Instances can be interrupted by Amazon EC2 with a two-minute notification when the capacity is needed back.
 *
 * The default is On-Demand
 *
 * For more information about Amazon EC2 capacity options, see [Instance purchasing options](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-purchasing-options.html) in the *Amazon EC2 User Guide* .
 */
export type CapacityProviderInstanceLaunchTemplateCapacityOptionType = (typeof CapacityProviderInstanceLaunchTemplateCapacityOptionType)[keyof typeof CapacityProviderInstanceLaunchTemplateCapacityOptionType];
export declare const CapacityProviderInstanceRequirementsRequestAcceleratorManufacturersItem: {
    readonly AmazonWebServices: "amazon-web-services";
    readonly Amd: "amd";
    readonly Habana: "habana";
    readonly Nvidia: "nvidia";
    readonly Xilinx: "xilinx";
};
export type CapacityProviderInstanceRequirementsRequestAcceleratorManufacturersItem = (typeof CapacityProviderInstanceRequirementsRequestAcceleratorManufacturersItem)[keyof typeof CapacityProviderInstanceRequirementsRequestAcceleratorManufacturersItem];
export declare const CapacityProviderInstanceRequirementsRequestAcceleratorNamesItem: {
    readonly A10g: "a10g";
    readonly A100: "a100";
    readonly H100: "h100";
    readonly Inferentia: "inferentia";
    readonly K520: "k520";
    readonly K80: "k80";
    readonly M60: "m60";
    readonly RadeonProV520: "radeon-pro-v520";
    readonly T4: "t4";
    readonly T4g: "t4g";
    readonly Vu9p: "vu9p";
    readonly V100: "v100";
    readonly L40s: "l40s";
};
export type CapacityProviderInstanceRequirementsRequestAcceleratorNamesItem = (typeof CapacityProviderInstanceRequirementsRequestAcceleratorNamesItem)[keyof typeof CapacityProviderInstanceRequirementsRequestAcceleratorNamesItem];
export declare const CapacityProviderInstanceRequirementsRequestAcceleratorTypesItem: {
    readonly Gpu: "gpu";
    readonly Fpga: "fpga";
    readonly Inference: "inference";
};
export type CapacityProviderInstanceRequirementsRequestAcceleratorTypesItem = (typeof CapacityProviderInstanceRequirementsRequestAcceleratorTypesItem)[keyof typeof CapacityProviderInstanceRequirementsRequestAcceleratorTypesItem];
export declare const CapacityProviderInstanceRequirementsRequestBareMetal: {
    readonly Included: "included";
    readonly Required: "required";
    readonly Excluded: "excluded";
};
/**
 * Indicates whether to include bare metal instance types. Set to `included` to allow bare metal instances, `excluded` to exclude them, or `required` to use only bare metal instances.
 */
export type CapacityProviderInstanceRequirementsRequestBareMetal = (typeof CapacityProviderInstanceRequirementsRequestBareMetal)[keyof typeof CapacityProviderInstanceRequirementsRequestBareMetal];
export declare const CapacityProviderInstanceRequirementsRequestBurstablePerformance: {
    readonly Included: "included";
    readonly Required: "required";
    readonly Excluded: "excluded";
};
/**
 * Indicates whether to include burstable performance instance types (T2, T3, T3a, T4g). Set to `included` to allow burstable instances, `excluded` to exclude them, or `required` to use only burstable instances.
 */
export type CapacityProviderInstanceRequirementsRequestBurstablePerformance = (typeof CapacityProviderInstanceRequirementsRequestBurstablePerformance)[keyof typeof CapacityProviderInstanceRequirementsRequestBurstablePerformance];
export declare const CapacityProviderInstanceRequirementsRequestCpuManufacturersItem: {
    readonly Intel: "intel";
    readonly Amd: "amd";
    readonly AmazonWebServices: "amazon-web-services";
};
export type CapacityProviderInstanceRequirementsRequestCpuManufacturersItem = (typeof CapacityProviderInstanceRequirementsRequestCpuManufacturersItem)[keyof typeof CapacityProviderInstanceRequirementsRequestCpuManufacturersItem];
export declare const CapacityProviderInstanceRequirementsRequestInstanceGenerationsItem: {
    readonly Current: "current";
    readonly Previous: "previous";
};
export type CapacityProviderInstanceRequirementsRequestInstanceGenerationsItem = (typeof CapacityProviderInstanceRequirementsRequestInstanceGenerationsItem)[keyof typeof CapacityProviderInstanceRequirementsRequestInstanceGenerationsItem];
export declare const CapacityProviderInstanceRequirementsRequestLocalStorage: {
    readonly Included: "included";
    readonly Required: "required";
    readonly Excluded: "excluded";
};
/**
 * Indicates whether to include instance types with local storage. Set to `included` to allow local storage, `excluded` to exclude it, or `required` to use only instances with local storage.
 */
export type CapacityProviderInstanceRequirementsRequestLocalStorage = (typeof CapacityProviderInstanceRequirementsRequestLocalStorage)[keyof typeof CapacityProviderInstanceRequirementsRequestLocalStorage];
export declare const CapacityProviderInstanceRequirementsRequestLocalStorageTypesItem: {
    readonly Hdd: "hdd";
    readonly Ssd: "ssd";
};
export type CapacityProviderInstanceRequirementsRequestLocalStorageTypesItem = (typeof CapacityProviderInstanceRequirementsRequestLocalStorageTypesItem)[keyof typeof CapacityProviderInstanceRequirementsRequestLocalStorageTypesItem];
export declare const CapacityProviderManagedInstancesMonitoringOptions: {
    readonly Basic: "BASIC";
    readonly Detailed: "DETAILED";
};
export type CapacityProviderManagedInstancesMonitoringOptions = (typeof CapacityProviderManagedInstancesMonitoringOptions)[keyof typeof CapacityProviderManagedInstancesMonitoringOptions];
export declare const CapacityProviderManagedInstancesProviderPropagateTags: {
    readonly CapacityProvider: "CAPACITY_PROVIDER";
    readonly None: "NONE";
};
/**
 * Determines whether tags from the capacity provider are automatically applied to Amazon ECS Managed Instances. This helps with cost allocation and resource management by ensuring consistent tagging across your infrastructure.
 */
export type CapacityProviderManagedInstancesProviderPropagateTags = (typeof CapacityProviderManagedInstancesProviderPropagateTags)[keyof typeof CapacityProviderManagedInstancesProviderPropagateTags];
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 DaemonPropagateTags: {
    readonly Daemon: "DAEMON";
    readonly None: "NONE";
};
/**
 * Specifies whether tags are propagated from the daemon to the daemon tasks.
 */
export type DaemonPropagateTags = (typeof DaemonPropagateTags)[keyof typeof DaemonPropagateTags];
export declare const DaemonStatus: {
    readonly Active: "ACTIVE";
    readonly DeleteInProgress: "DELETE_IN_PROGRESS";
};
export type DaemonStatus = (typeof DaemonStatus)[keyof typeof DaemonStatus];
export declare const ExpressGatewayServiceAccessType: {
    readonly Public: "PUBLIC";
    readonly Private: "PRIVATE";
};
export type ExpressGatewayServiceAccessType = (typeof ExpressGatewayServiceAccessType)[keyof typeof ExpressGatewayServiceAccessType];
export declare const ExpressGatewayServiceScalingMetric: {
    readonly AverageCpu: "AVERAGE_CPU";
    readonly AverageMemory: "AVERAGE_MEMORY";
    readonly RequestCountPerTarget: "REQUEST_COUNT_PER_TARGET";
};
export type ExpressGatewayServiceScalingMetric = (typeof ExpressGatewayServiceScalingMetric)[keyof typeof ExpressGatewayServiceScalingMetric];
export declare const ExpressGatewayServiceStatusCode: {
    readonly Active: "ACTIVE";
    readonly Draining: "DRAINING";
    readonly Inactive: "INACTIVE";
};
export type ExpressGatewayServiceStatusCode = (typeof ExpressGatewayServiceStatusCode)[keyof typeof ExpressGatewayServiceStatusCode];
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*.
 *  The default behavior of ``AvailabilityZoneRebalancing`` differs between create and update requests:
 *   +  For create service requests, when no value is specified for ``AvailabilityZoneRebalancing``, Amazon ECS defaults the value to ``ENABLED``.
 *   +  For update service requests, when no value is specified for ``AvailabilityZoneRebalancing``, Amazon ECS defaults to the existing service’s ``AvailabilityZoneRebalancing`` value. If the service never had an ``AvailabilityZoneRebalancing`` value set, Amazon ECS treats this as ``DISABLED``.
 */
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 ServiceConnectAccessLogConfigurationFormat: {
    readonly Text: "TEXT";
    readonly Json: "JSON";
};
/**
 * The format for Service Connect access log output. Choose TEXT for human-readable logs or JSON for structured data that integrates well with log analysis tools.
 */
export type ServiceConnectAccessLogConfigurationFormat = (typeof ServiceConnectAccessLogConfigurationFormat)[keyof typeof ServiceConnectAccessLogConfigurationFormat];
export declare const ServiceConnectAccessLogConfigurationIncludeQueryParameters: {
    readonly Disabled: "DISABLED";
    readonly Enabled: "ENABLED";
};
/**
 * Specifies whether to include query parameters in Service Connect access logs.
 *  When enabled, query parameters from HTTP requests are included in the access logs. Consider security and privacy implications when enabling this feature, as query parameters may contain sensitive information such as request IDs and tokens. By default, this parameter is ``DISABLED``.
 */
export type ServiceConnectAccessLogConfigurationIncludeQueryParameters = (typeof ServiceConnectAccessLogConfigurationIncludeQueryParameters)[keyof typeof ServiceConnectAccessLogConfigurationIncludeQueryParameters];
export declare const ServiceDeploymentConfigurationStrategy: {
    readonly Rolling: "ROLLING";
    readonly BlueGreen: "BLUE_GREEN";
    readonly Linear: "LINEAR";
    readonly Canary: "CANARY";
};
/**
 * The deployment strategy for the service. Choose from these valid values:
 *   +  ``ROLLING`` - When you create a service which uses the rolling update (``ROLLING``) deployment strategy, the Amazon ECS service scheduler replaces the currently running tasks with new tasks. The number of tasks that Amazon ECS adds or removes from the service during a rolling update is controlled by the service deployment configuration.
 *   +  ``BLUE_GREEN`` - A blue/green deployment strategy (``BLUE_GREEN``) is a release methodology that reduces downtime and risk by running two identical production environments called blue and green. With Amazon ECS blue/green deployments, you can validate new service revisions before directing production traffic to them. This approach provides a safer way to deploy changes with the ability to quickly roll back if needed.
 *   +  ``LINEAR`` - A *linear* deployment strategy (``LINEAR``) gradually shifts traffic from the current production environment to a new environment in equal percentages over time. With Amazon ECS linear deployments, you can control the pace of traffic shifting and validate new service revisions with increasing amounts of production traffic.
 *   +  ``CANARY`` - A *canary* deployment strategy (``CANARY``) shifts a small percentage of traffic to the new service revision first, then shifts the remaining traffic all at once after a specified time period. This allows you to test the new version with a subset of users before full deployment.
 */
export type ServiceDeploymentConfigurationStrategy = (typeof ServiceDeploymentConfigurationStrategy)[keyof typeof ServiceDeploymentConfigurationStrategy];
export declare const ServiceDeploymentControllerType: {
    readonly CodeDeploy: "CODE_DEPLOY";
    readonly Ecs: "ECS";
    readonly External: "EXTERNAL";
};
/**
 * The deployment controller type to use.
 *  The deployment controller is the mechanism that determines how tasks are deployed for your service. The valid options are:
 *   +  ECS
 *  When you create a service which uses the ``ECS`` deployment controller, you can choose between the following deployment strategies:
 *   +  ``ROLLING``: When you create a service which uses the *rolling update* (``ROLLING``) deployment strategy, the ECS service scheduler replaces the currently running tasks with new tasks. The number of tasks that ECS adds or removes from the service during a rolling update is controlled by the service deployment configuration.
 *  Rolling update deployments are best suited for the following scenarios:
 *   +  Gradual service updates: You need to update your service incrementally without taking the entire service offline at once.
 *   +  Limited resource requirements: You want to avoid the additional resource costs of running two complete environments simultaneously (as required by blue/green deployments).
 *   +  Acceptable deployment time: Your application can tolerate a longer deployment process, as rolling updates replace tasks one by one.
 *   +  No need for instant roll back: Your service can tolerate a rollback process that takes minutes rather than seconds.
 *   +  Simple deployment process: You prefer a straightforward deployment approach without the complexity of managing multiple environments, target groups, and listeners.
 *   +  No load balancer requirement: Your service doesn't use or require a load balancer, ALB, NLB, or Service Connect (which are required for blue/green deployments).
 *   +  Stateful applications: Your application maintains state that makes it difficult to run two parallel environments.
 *   +  Cost sensitivity: You want to minimize deployment costs by not running duplicate environments during deployment.
 *
 *  Rolling updates are the default deployment strategy for services and provide a balance between deployment safety and resource efficiency for many common application scenarios.
 *   +  ``BLUE_GREEN``: A *blue/green* deployment strategy (``BLUE_GREEN``) is a release methodology that reduces downtime and risk by running two identical production environments called blue and green. With ECS blue/green deployments, you can validate new service revisions before directing production traffic to them. This approach provides a safer way to deploy changes with the ability to quickly roll back if needed.
 *  ECS blue/green deployments are best suited for the following scenarios:
 *   +  Service validation: When you need to validate new service revisions before directing production traffic to them
 *   +  Zero downtime: When your service requires zero-downtime deployments
 *   +  Instant roll back: When you need the ability to quickly roll back if issues are detected
 *   +  Load balancer requirement: When your service uses ALB, NLB, or Service Connect
 *
 *
 *   +  External
 *  Use a third-party deployment controller.
 *   +  Blue/green deployment (powered by ACD)
 *  ACD installs an updated version of the application as a new replacement task set and reroutes production traffic from the original application task set to the replacement task set. The original task set is terminated after a successful deployment. Use this deployment controller to verify a new deployment of a service before sending production traffic to it.
 *
 *  When updating the deployment controller for a service, consider the following depending on the type of migration you're performing.
 *   +  If you have a template that contains the ``EXTERNAL`` deployment controller information as well as ``TaskSet`` and ``PrimaryTaskSet`` resources, and you remove the task set resources from the template when updating from ``EXTERNAL`` to ``ECS``, the ``DescribeTaskSet`` and ``DeleteTaskSet`` API calls will return a 400 error after the deployment controller is updated to ``ECS``. This results in a delete failure on the task set resources, even though the stack transitions to ``UPDATE_COMPLETE`` status. For more information, see [Resource removed from stack but not deleted](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/troubleshooting.html#troubleshooting-errors-resource-removed-not-deleted) in the CFNlong User Guide. To fix this issue, delete the task sets directly using the ECS``DeleteTaskSet`` API. For more information about how to delete a task set, see [DeleteTaskSet](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DeleteTaskSet.html) in the ECSlong API Reference.
 *   +  If you're migrating from ``CODE_DEPLOY`` to ``ECS`` with a new task definition and CFN performs a rollback operation, the ECS``UpdateService`` request fails with the following error:
 *  Resource handler returned message: "Invalid request provided: Unable to update task definition on services with a CODE_DEPLOY deployment controller.
 *   +  After a successful migration from ``ECS`` to ``EXTERNAL`` deployment controller, you need to manually remove the ``ACTIVE`` task set, because ECS no longer manages the deployment. For information about how to delete a task set, see [DeleteTaskSet](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DeleteTaskSet.html) in the ECSlong API Reference.
 */
export type ServiceDeploymentControllerType = (typeof ServiceDeploymentControllerType)[keyof typeof ServiceDeploymentControllerType];
export declare const ServiceDeploymentLifecycleHookLifecycleStagesItem: {
    readonly ReconcileService: "RECONCILE_SERVICE";
    readonly PreScaleUp: "PRE_SCALE_UP";
    readonly PostScaleUp: "POST_SCALE_UP";
    readonly TestTrafficShift: "TEST_TRAFFIC_SHIFT";
    readonly PostTestTrafficShift: "POST_TEST_TRAFFIC_SHIFT";
    readonly ProductionTrafficShift: "PRODUCTION_TRAFFIC_SHIFT";
    readonly PostProductionTrafficShift: "POST_PRODUCTION_TRAFFIC_SHIFT";
};
export type ServiceDeploymentLifecycleHookLifecycleStagesItem = (typeof ServiceDeploymentLifecycleHookLifecycleStagesItem)[keyof typeof ServiceDeploymentLifecycleHookLifecycleStagesItem];
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*.
 *   If you want to use Managed Instances, you must use the ``capacityProviderStrategy`` request parameter
 */
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];