export interface Service {
    serviceArn?: string;
    serviceName?: string;
    clusterArn?: string;
    status?: string;
    desiredCount?: number;
    runningCount?: number;
    pendingCount?: number;
    launchType?: string;
    taskDefinition?: string;
    deployments?: Deployment[];
    events?: ServiceEvent[];
}
export interface Deployment {
    id?: string;
    status?: string;
    taskDefinition?: string;
    desiredCount?: number;
    runningCount?: number;
    pendingCount?: number;
    createdAt?: string;
    updatedAt?: string;
}
export interface ServiceEvent {
    id?: string;
    createdAt?: string;
    message?: string;
}
export interface DescribeServicesOptions {
    cluster: string;
    services: string[];
}
export interface Task {
    taskArn?: string;
    taskDefinitionArn?: string;
    clusterArn?: string;
    /** ECS sets this to `service:<serviceName>` for service-owned tasks. */
    group?: string;
    lastStatus?: string;
    desiredStatus?: string;
    containers?: Container[];
    createdAt?: string;
    startedAt?: string;
    stoppedAt?: string;
}
export interface Container {
    containerArn?: string;
    name?: string;
    lastStatus?: string;
    exitCode?: number;
    reason?: string;
}
/**
 * ECS service management using direct API calls
 */
export declare class ECSClient {
    private client;
    private region;
    constructor(region?: string, profile?: string);
    /**
     * Describe ECS services
     */
    describeServices(options: DescribeServicesOptions): Promise<{
        services?: Service[];
        failures?: any[];
    }>;
    /**
     * List ECS services in a cluster
     */
    listServices(cluster: string, options?: {
        nextToken?: string;
        maxResults?: number;
    }): Promise<{
        serviceArns?: string[];
        nextToken?: string;
    }>;
    /**
     * List tasks in a cluster
     */
    listTasks(cluster: string, serviceName?: string, options?: {
        nextToken?: string;
        maxResults?: number;
    }): Promise<{
        taskArns?: string[];
        nextToken?: string;
    }>;
    /**
     * Describe ECS tasks
     */
    describeTasks(cluster: string, tasks: string[]): Promise<{
        tasks?: Task[];
        failures?: any[];
    }>;
    /**
     * Update ECS service (e.g., force new deployment)
     */
    updateService(options: {
        cluster: string;
        service: string;
        forceNewDeployment?: boolean;
        desiredCount?: number;
        taskDefinition?: string;
    }): Promise<{
        service?: Service;
    }>;
    /**
     * Create a new ECS service
     */
    createService(options: {
        cluster: string;
        serviceName: string;
        taskDefinition: string;
        desiredCount: number;
        launchType?: 'EC2' | 'FARGATE' | 'EXTERNAL';
        networkConfiguration?: {
            awsvpcConfiguration: {
                subnets: string[];
                securityGroups?: string[];
                assignPublicIp?: 'ENABLED' | 'DISABLED';
            };
        };
        loadBalancers?: Array<{
            targetGroupArn: string;
            containerName: string;
            containerPort: number;
        }>;
        healthCheckGracePeriodSeconds?: number;
        deploymentConfiguration?: {
            minimumHealthyPercent?: number;
            maximumPercent?: number;
        };
    }): Promise<{
        service?: Service;
    }>;
    /**
     * Delete an ECS service
     */
    deleteService(options: {
        cluster: string;
        service: string;
        force?: boolean;
    }): Promise<{
        service?: Service;
    }>;
    /**
     * List ECS clusters
     */
    listClusters(options?: {
        nextToken?: string;
        maxResults?: number;
    }): Promise<{
        clusterArns?: string[];
        nextToken?: string;
    }>;
    /**
     * Describe ECS clusters
     */
    describeClusters(clusters: string[]): Promise<{
        clusters?: any[];
        failures?: any[];
    }>;
    /**
     * Stop a running task
     */
    stopTask(options: {
        cluster: string;
        task: string;
        reason?: string;
    }): Promise<{
        task?: Task;
    }>;
    /**
     * Run a one-off task
     */
    runTask(options: {
        cluster: string;
        taskDefinition: string;
        count?: number;
        launchType?: 'EC2' | 'FARGATE' | 'EXTERNAL';
        networkConfiguration?: {
            awsvpcConfiguration: {
                subnets: string[];
                securityGroups?: string[];
                assignPublicIp?: 'ENABLED' | 'DISABLED';
            };
        };
        overrides?: {
            containerOverrides?: Array<{
                name: string;
                command?: string[];
                environment?: Array<{
                    name: string;
                    value: string;
                }>;
            }>;
        };
    }): Promise<{
        tasks?: Task[];
        failures?: any[];
    }>;
    /**
     * Register a new task definition
     */
    registerTaskDefinition(options: {
        family: string;
        containerDefinitions: Array<{
            name: string;
            image: string;
            memory?: number;
            cpu?: number;
            essential?: boolean;
            portMappings?: Array<{
                containerPort: number;
                hostPort?: number;
                protocol?: 'tcp' | 'udp';
            }>;
            environment?: Array<{
                name: string;
                value: string;
            }>;
            secrets?: Array<{
                name: string;
                valueFrom: string;
            }>;
            logConfiguration?: {
                logDriver: string;
                options?: Record<string, string>;
            };
        }>;
        cpu?: string;
        memory?: string;
        networkMode?: 'bridge' | 'host' | 'awsvpc' | 'none';
        requiresCompatibilities?: Array<'EC2' | 'FARGATE' | 'EXTERNAL'>;
        executionRoleArn?: string;
        taskRoleArn?: string;
    }): Promise<{
        taskDefinition?: any;
    }>;
    /**
     * Deregister a task definition
     */
    deregisterTaskDefinition(taskDefinition: string): Promise<{
        taskDefinition?: any;
    }>;
    /**
     * Describe task definitions
     */
    describeTaskDefinition(taskDefinition: string): Promise<{
        taskDefinition?: any;
        tags?: any[];
    }>;
    /**
     * List task definition families
     */
    listTaskDefinitionFamilies(options?: {
        familyPrefix?: string;
        status?: 'ACTIVE' | 'INACTIVE' | 'ALL';
    }): Promise<{
        families?: string[];
    }>;
    /**
     * Wait for service to become stable
     */
    waitForServiceStable(cluster: string, service: string, maxAttempts?: number, delayMs?: number): Promise<boolean>;
    /**
     * Helper: Force new deployment
     */
    forceNewDeployment(cluster: string, service: string): Promise<{
        service?: Service;
    }>;
    /**
     * Helper: Scale service
     */
    scaleService(cluster: string, service: string, desiredCount: number): Promise<{
        service?: Service;
    }>;
}
