import { ToolResult } from '../types.js';
import { WorkspaceService } from './WorkspaceService.js';
export interface DockerBuildArgs {
    context?: string;
    dockerfile?: string;
    tag?: string;
    build_args?: Record<string, string>;
    target?: string;
    no_cache?: boolean;
    pull?: boolean;
    quiet?: boolean;
    squash?: boolean;
    platform?: string;
    progress?: 'auto' | 'plain' | 'tty';
    secret?: string[];
    ssh?: string;
    network?: string;
}
export interface DockerRunArgs {
    image: string;
    name?: string;
    command?: string;
    args?: string[];
    ports?: string[];
    volumes?: string[];
    env?: Record<string, string>;
    detach?: boolean;
    remove?: boolean;
    interactive?: boolean;
    tty?: boolean;
    network?: string;
    working_dir?: string;
    user?: string;
    memory?: string;
    cpus?: string;
    restart?: string;
    privileged?: boolean;
    read_only?: boolean;
    security_opt?: string[];
    tmpfs?: string[];
    ulimit?: string[];
    cap_add?: string[];
    cap_drop?: string[];
    device?: string[];
    entrypoint?: string;
    hostname?: string;
    init?: boolean;
    label?: Record<string, string>;
    log_driver?: string;
    log_opt?: Record<string, string>;
    mac_address?: string;
    shm_size?: string;
    stop_signal?: string;
    stop_timeout?: number;
}
export interface DockerComposeArgs {
    action: 'up' | 'down' | 'build' | 'logs' | 'ps' | 'exec' | 'restart' | 'stop' | 'start' | 'pull' | 'config' | 'kill' | 'pause' | 'unpause' | 'top';
    service?: string;
    file?: string;
    detach?: boolean;
    build?: boolean;
    force_recreate?: boolean;
    remove_orphans?: boolean;
    follow?: boolean;
    tail?: number;
    command?: string;
    scale?: Record<string, number>;
    profiles?: string[];
    env_file?: string;
    project_name?: string;
    timeout?: number;
    parallel?: number;
    no_deps?: boolean;
    abort_on_container_exit?: boolean;
    remove_volumes?: boolean;
}
export interface DockerImageArgs {
    action: 'list' | 'remove' | 'pull' | 'push' | 'tag' | 'inspect' | 'build' | 'prune' | 'history' | 'save' | 'load' | 'import';
    image?: string;
    tag?: string;
    repository?: string;
    file?: string;
    filter?: string;
    all?: boolean;
    force?: boolean;
    no_prune?: boolean;
    dangling?: boolean;
    until?: string;
}
export interface DockerContainerArgs {
    action: 'list' | 'start' | 'stop' | 'restart' | 'remove' | 'inspect' | 'logs' | 'exec' | 'stats' | 'kill' | 'pause' | 'unpause' | 'attach' | 'cp' | 'export' | 'port' | 'rename' | 'update' | 'wait' | 'prune';
    container?: string;
    command?: string;
    interactive?: boolean;
    tty?: boolean;
    user?: string;
    workdir?: string;
    env?: string[];
    follow?: boolean;
    tail?: number;
    since?: string;
    until?: string;
    timestamps?: boolean;
    details?: boolean;
    all?: boolean;
    filter?: string;
    force?: boolean;
    volumes?: boolean;
    signal?: string;
    time?: number;
    no_stream?: boolean;
    source?: string;
    destination?: string;
    archive?: boolean;
    new_name?: string;
    memory?: string;
    cpus?: string;
    restart?: string;
}
export interface DockerNetworkArgs {
    action: 'list' | 'create' | 'remove' | 'inspect' | 'connect' | 'disconnect' | 'prune';
    network?: string;
    container?: string;
    driver?: string;
    gateway?: string;
    subnet?: string;
    ip_range?: string;
    aux_address?: Record<string, string>;
    opt?: Record<string, string>;
    label?: Record<string, string>;
    internal?: boolean;
    attachable?: boolean;
    ingress?: boolean;
    ipv6?: boolean;
    alias?: string[];
    ip?: string;
    ip6?: string;
    link?: string[];
    link_local_ip?: string[];
    force?: boolean;
    filter?: string;
}
export interface DockerVolumeArgs {
    action: 'list' | 'create' | 'remove' | 'inspect' | 'prune';
    volume?: string;
    driver?: string;
    label?: Record<string, string>;
    opt?: Record<string, string>;
    force?: boolean;
    filter?: string;
    all?: boolean;
}
export interface DockerSystemArgs {
    action: 'info' | 'version' | 'events' | 'df' | 'prune';
    all?: boolean;
    volumes?: boolean;
    filter?: string;
    force?: boolean;
    since?: string;
    until?: string;
    format?: string;
}
export declare class DockerService {
    private workspaceService;
    private defaultTimeout;
    private buildTimeout;
    private pullTimeout;
    private runningContainers;
    constructor(workspaceService: WorkspaceService);
    /**
     * Get current workspace path
     */
    private getCurrentWorkspace;
    /**
     * Quote path if it contains spaces
     */
    private quotePath;
    /**
     * Check if Docker is available
     */
    checkDockerAvailability(): Promise<ToolResult>;
    /**
     * Execute Docker command with streaming support
     */
    private executeDockerCommand;
    /**
     * Build Docker image
     */
    buildImage(args: DockerBuildArgs): Promise<ToolResult>;
    /**
     * Run Docker container
     */
    runContainer(args: DockerRunArgs): Promise<ToolResult>;
    /**
     * Manage Docker Compose
     */
    dockerCompose(args: DockerComposeArgs): Promise<ToolResult>;
    /**
     * Manage Docker images
     */
    manageImages(args: DockerImageArgs): Promise<ToolResult>;
    /**
     * Manage Docker containers
     */
    manageContainers(args: DockerContainerArgs): Promise<ToolResult>;
    /**
     * Manage Docker networks
     */
    manageNetworks(args: DockerNetworkArgs): Promise<ToolResult>;
    /**
     * Manage Docker volumes
     */
    manageVolumes(args: DockerVolumeArgs): Promise<ToolResult>;
    /**
     * Docker system operations
     */
    systemOperations(args: DockerSystemArgs): Promise<ToolResult>;
    /**
     * Get running containers tracked by this service
     */
    getTrackedContainers(): Map<string, any>;
    /**
     * Clean up tracked containers
     */
    cleanupTrackedContainers(): Promise<ToolResult>;
    /**
     * Generate Dockerfile template
     */
    generateDockerfile(language: string, framework?: string): Promise<ToolResult>;
    /**
     * Generate Docker Compose template
     */
    generateDockerCompose(services: string[], includeDatabase?: boolean): Promise<ToolResult>;
    /**
     * Generate Node.js Dockerfile
     */
    private generateNodeDockerfile;
    /**
     * Generate Python Dockerfile
     */
    private generatePythonDockerfile;
    /**
     * Generate Java Dockerfile
     */
    private generateJavaDockerfile;
    /**
     * Generate Go Dockerfile
     */
    private generateGoDockerfile;
    /**
     * Generate Rust Dockerfile
     */
    private generateRustDockerfile;
    /**
     * Generate Docker Compose content
     */
    private generateDockerComposeContent;
    /**
     * Start Docker Compose services (focused action)
     */
    dockerComposeUp(args: {
        file?: string;
        services?: string[];
        detach?: boolean;
        build?: boolean;
        project_name?: string;
    }): Promise<ToolResult>;
    /**
     * Stop and remove Docker Compose services (focused action)
     */
    dockerComposeDown(args: {
        file?: string;
        volumes?: boolean;
        remove_orphans?: boolean;
        project_name?: string;
    }): Promise<ToolResult>;
    /**
     * View Docker Compose service logs (focused action)
     */
    dockerComposeLogs(args: {
        file?: string;
        services?: string[];
        follow?: boolean;
        tail?: number;
        project_name?: string;
    }): Promise<ToolResult>;
    /**
     * Restart Docker Compose services (focused action)
     */
    dockerComposeRestart(args: {
        file?: string;
        services?: string[];
        project_name?: string;
    }): Promise<ToolResult>;
    /**
     * Start a Docker container (focused action)
     */
    dockerContainerStart(args: {
        container: string;
    }): Promise<ToolResult>;
    /**
     * Stop a Docker container (focused action)
     */
    dockerContainerStop(args: {
        container: string;
        timeout?: number;
    }): Promise<ToolResult>;
    /**
     * Restart a Docker container (focused action)
     */
    dockerContainerRestart(args: {
        container: string;
        timeout?: number;
    }): Promise<ToolResult>;
    /**
     * Remove a Docker container (focused action)
     */
    dockerContainerRemove(args: {
        container: string;
        force?: boolean;
        volumes?: boolean;
    }): Promise<ToolResult>;
    /**
     * Get Docker container logs (focused action)
     */
    dockerContainerLogs(args: {
        container: string;
        follow?: boolean;
        tail?: number;
        since?: string;
    }): Promise<ToolResult>;
    /**
     * Execute command in running Docker container (focused action)
     */
    dockerContainerExec(args: {
        container: string;
        command: string;
        interactive?: boolean;
        tty?: boolean;
    }): Promise<ToolResult>;
    /**
     * Pull a Docker image from registry (focused action)
     */
    dockerImagePull(args: {
        image: string;
        all_tags?: boolean;
    }): Promise<ToolResult>;
    /**
     * Push a Docker image to registry (focused action)
     */
    dockerImagePush(args: {
        image: string;
        all_tags?: boolean;
    }): Promise<ToolResult>;
    /**
     * Remove Docker image(s) (focused action)
     */
    dockerImageRemove(args: {
        image: string;
        force?: boolean;
        no_prune?: boolean;
    }): Promise<ToolResult>;
    /**
     * Build Docker image from Dockerfile (focused action)
     */
    dockerImageBuild(args: {
        context?: string;
        dockerfile?: string;
        tag?: string;
        build_args?: Record<string, string>;
        no_cache?: boolean;
    }): Promise<ToolResult>;
    /**
     * Tag a Docker image (focused action)
     */
    dockerImageTag(args: {
        source: string;
        target: string;
    }): Promise<ToolResult>;
}
//# sourceMappingURL=DockerService.d.ts.map