import * as pulumi from '@pulumi/pulumi';
import * as aws from '@pulumi/aws';
import * as awsx from '@pulumi/awsx';
import { TaskSize } from './task-size';
export declare namespace EcsService {
    /**
     * Represents the EFS-backed persistent storage attached to an ECS service.
     * Created automatically when `volumes` are configured.
     */
    type PersistentStorage = {
        fileSystem: aws.efs.FileSystem;
        accessPoint: aws.efs.AccessPoint;
        mountTargets: pulumi.Output<aws.efs.MountTarget[]>;
    };
    /**
     * Create a named volume that can be mounted into one or more containers.
     * Used with Amazon EFS to enable persistent storage across:
     * - Container restarts
     * - Multiple containers
     */
    type PersistentStorageVolume = {
        name: pulumi.Input<string>;
    };
    /**
     * Specifies how an EFS volume is mounted into a container.
     * `sourceVolume`: Name of the defined ECS service volume.
     * `containerPath`: Path into which the volume is mounted in the container.
     *
     * @see {@link PersistentStorageVolume} - Required to define volumes before mounting
     * @see {@link Container} - Where `mountPoints` are specified
     */
    type PersistentStorageMountPoint = {
        sourceVolume: pulumi.Input<string>;
        containerPath: pulumi.Input<string>;
        readOnly?: pulumi.Input<boolean>;
    };
    /**
     * Container configuration for the ECS task definition.
     * Multiple containers can be defined to create multi-container tasks.
     */
    type Container = {
        name: pulumi.Input<string>;
        image: pulumi.Input<string>;
        portMappings?: pulumi.Input<pulumi.Input<aws.ecs.PortMapping>[]>;
        command?: pulumi.Input<pulumi.Input<string>[]>;
        mountPoints?: PersistentStorageMountPoint[];
        environment?: pulumi.Input<aws.ecs.KeyValuePair[]>;
        secrets?: pulumi.Input<aws.ecs.Secret[]>;
        dependsOn?: pulumi.Input<aws.ecs.ContainerDependency[]>;
        /**
         * If `false`, task can continue running if this container fails.
         * Should be `false` for containers that execute and then tear down.
         *
         * Examples: Database migration, or configuration containers
         *
         * All containers not marked as `false` will be essential by default.
         */
        essential?: pulumi.Input<boolean>;
        healthCheck?: pulumi.Input<aws.ecs.HealthCheck>;
    };
    type Tags = {
        [key: string]: pulumi.Input<string>;
    };
    type LoadBalancerConfig = {
        containerName: pulumi.Input<string>;
        containerPort: pulumi.Input<number>;
        targetGroupArn: aws.lb.TargetGroup['arn'];
    };
    type RoleInlinePolicy = aws.types.input.iam.RoleInlinePolicy;
    type Args = {
        cluster: pulumi.Input<aws.ecs.Cluster>;
        vpc: pulumi.Input<awsx.ec2.Vpc>;
        containers: EcsService.Container[];
        loadBalancers?: pulumi.Input<LoadBalancerConfig[]>;
        volumes?: pulumi.Input<pulumi.Input<EcsService.PersistentStorageVolume>[]>;
        /**
         * Name to set for the ECS Service.
         * @default ${this.name}
         */
        name?: pulumi.Input<string>;
        /**
         * Type of deployment controller to use.
         * @default "ECS"
         */
        deploymentController?: 'ECS' | 'CODE_DEPLOY' | 'EXTERNAL';
        /**
         * Number of instances of the task definition to place and keep running.
         * @default 1
         */
        desiredCount?: pulumi.Input<number>;
        /**
         * Family for the task definition. Used for grouping of multiple versions.
         * @default ${this.name}-task-definition-${stackName}
         */
        family?: pulumi.Input<string>;
        /**
         * CPU and memory size used for running the container.
         * Available predefined options are:
         * - `small` (0.25 vCPU, 0.5 GB memory)
         * - `medium` (0.5 vCPU, 1 GB memory)
         * - `large` (1 vCPU memory, 2 GB memory)
         * - `xlarge` (2 vCPU, 4 GB memory)
         * - `2xlarge` (4 vCPU, 8 GB memory)
         * - `3xlarge` (8 vCPU, 16 GB memory)
         * @default "small"
         */
        size?: pulumi.Input<TaskSize>;
        /**
         * Name prefix of the AWS CloudWatch log group.
         * @default /ecs/${this.name}-
         */
        logGroupNamePrefix?: pulumi.Input<string>;
        /**
         * Custom service security group
         * In case no security group is provided, default security group will be automatically created.
         */
        securityGroup?: pulumi.Input<aws.ec2.SecurityGroup>;
        assignPublicIp?: boolean;
        taskExecutionRoleInlinePolicies?: pulumi.Input<pulumi.Input<RoleInlinePolicy>[]>;
        taskRoleInlinePolicies?: pulumi.Input<pulumi.Input<RoleInlinePolicy>[]>;
        /**
         * Registers tasks with AWS Cloud Map and creates discoverable DNS entries for each task.
         * Simplifies service-to-service communication by enabling service finding based on DNS records such as `http://serviceName.local`.
         *
         * @default false
         */
        enableServiceAutoDiscovery?: boolean;
        autoscaling?: pulumi.Input<{
            /**
             * Is autoscaling enabled or disabled.
             *
             * @default false
             */
            enabled: boolean;
            /**
             * Min capacity of the scalable target.
             *
             * @default 1
             */
            minCount?: pulumi.Input<number>;
            /**
             * Max capacity of the scalable target.
             *
             * @default 1
             */
            maxCount?: pulumi.Input<number>;
        }>;
        /**
         * AWS region used for region-specific ECS settings such as CloudWatch Logs.
         * When omitted, the region is resolved from the active AWS provider.
         */
        region?: pulumi.Input<string>;
        /**
         * A map of tags to assign to the resource.
         */
        tags?: pulumi.Input<EcsService.Tags>;
    };
}
export declare class EcsService extends pulumi.ComponentResource {
    name: string;
    vpc: pulumi.Output<awsx.ec2.Vpc>;
    logGroup: aws.cloudwatch.LogGroup;
    taskDefinition: aws.ecs.TaskDefinition;
    taskExecutionRole: aws.iam.Role;
    taskRole: aws.iam.Role;
    service: aws.ecs.Service;
    securityGroups: pulumi.Output<aws.ec2.SecurityGroup>[];
    serviceDiscoveryService?: aws.servicediscovery.Service;
    persistentStorage: pulumi.Output<EcsService.PersistentStorage | undefined>;
    constructor(name: string, args: EcsService.Args, opts?: pulumi.ComponentResourceOptions);
    static createTcpPortMapping(port: pulumi.Input<number>): aws.ecs.PortMapping;
    private createLogGroup;
    private createTaskDefinition;
    private createTaskDefinitionVolumes;
    private createContainerDefinition;
    private createTaskExecutionRole;
    private createTaskRole;
    private addSecurityGroup;
    private createDefaultSecurityGroup;
    private createEcsService;
    private createServiceDiscovery;
    private createPrivateDnsNameSpace;
    private enableAutoscaling;
    private createPersistentStorage;
}
//# sourceMappingURL=index.d.ts.map