/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: BUSL-1.1
 */
/// <reference types="node" />
import FSExtra from 'fs-extra';
import Docker from 'dockerode';
import { InstanceInfo, LogEntry } from './types';
import { Task } from './taskManager';
import { LocalInstanceHealth } from '@kapeta/schemas';
type StringMap = {
    [key: string]: string;
};
export type PortMap = {
    [key: string]: {
        containerPort: string;
        protocol: string;
        hostPort: string;
    };
};
export interface DockerMounts {
    Target: string;
    Source: string;
    Type: string;
    ReadOnly: boolean;
    Consistency: string;
    Labels?: StringMap;
}
export type DockerContainerStatus = 'created' | 'running' | 'paused' | 'restarting' | 'removing' | 'exited' | 'dead';
export type DockerContainerHealth = 'starting' | 'healthy' | 'unhealthy' | 'none';
export declare const CONTAINER_LABEL_PORT_PREFIX = "kapeta_port-";
export declare const COMPOSE_LABEL_PROJECT = "com.docker.compose.project";
export declare const COMPOSE_LABEL_SERVICE = "com.docker.compose.service";
export declare const HEALTH_CHECK_TIMEOUT: number;
declare class ContainerManager {
    private _docker;
    private _alive;
    private _mountDir;
    private _version;
    private _lastDockerAccessCheck;
    private logStreams;
    private _latestImagePulls;
    constructor();
    initialize(): Promise<void>;
    checkAlive(): Promise<boolean>;
    isAlive(): boolean;
    getMountPoint(systemId: string, ref: string, mountName: string): string;
    createMounts(systemId: string, kind: string, mountOpts: StringMap | null | undefined): Promise<StringMap>;
    createVolumes(systemId: string, serviceId: string, mountOpts: StringMap | null | undefined): Promise<DockerMounts[]>;
    ping(): Promise<void>;
    docker(): Docker;
    getContainerByName(containerName: string): Promise<ContainerInfo | undefined>;
    pull(image: string): Promise<boolean>;
    toDockerMounts(mounts: StringMap): DockerMounts[];
    toDockerHealth(health: LocalInstanceHealth): {
        Test: string[];
        Interval: number;
        Timeout: number;
        Retries: any;
    };
    private applyHash;
    ensureContainer(opts: any): Promise<Docker.Container>;
    private createOrUpdateContainer;
    private startContainer;
    waitForReady(container: Docker.Container, attempt?: number): Promise<void>;
    _isReady(container: Docker.Container): Promise<boolean>;
    remove(container: Docker.Container, opts?: {
        force?: boolean;
    }): Promise<void>;
    /**
     *
     * @param name
     * @return {Promise<ContainerInfo>}
     */
    get(name: string): Promise<ContainerInfo | undefined>;
    getLogs(instance: InstanceInfo): Promise<LogEntry[]>;
    stopLogListening(systemId: string, instanceId: string): Promise<void>;
    ensureLogListening(systemId: string, instanceId: string, handler: (log: LogEntry) => void): Promise<void>;
    buildDockerImage(dockerFile: string, imageName: string): Task<void>;
}
declare class ClosableLogStream {
    private readonly stream;
    private readonly eventEmitter;
    constructor(stream: FSExtra.ReadStream);
    onLog(listener: (log: LogEntry) => void): () => void;
    onEnd(listener: () => void): () => void;
    onError(listener: (error: Error) => void): () => void;
    close(): Promise<void>;
}
export declare class ContainerInfo {
    private readonly _container;
    /**
     *
     * @param {Docker.Container} dockerContainer
     */
    constructor(dockerContainer: Docker.Container);
    get native(): Docker.Container;
    isRunning(): Promise<boolean>;
    start(): Promise<void>;
    restart(): Promise<void>;
    stop(): Promise<void>;
    remove(opts?: {
        force?: boolean;
    }): Promise<void>;
    getPort(type: string): Promise<{
        containerPort: string;
        protocol: string;
        hostPort: string;
    } | null>;
    inspect(): Promise<Docker.ContainerInspectInfo | undefined>;
    status(): Promise<{
        Status: string;
        Running: boolean;
        Paused: boolean;
        Restarting: boolean;
        OOMKilled: boolean;
        Dead: boolean;
        Pid: number;
        ExitCode: number;
        Error: string;
        StartedAt: string;
        FinishedAt: string;
        Health?: {
            Status: string;
            FailingStreak: number;
            Log: {
                Start: string;
                End: string;
                ExitCode: number;
                Output: string;
            }[];
        } | undefined;
    } | undefined>;
    getPorts(): Promise<PortMap | false>;
    getLogStream(): Promise<ClosableLogStream>;
    getLogs(): Promise<LogEntry[]>;
}
export declare function getExtraHosts(dockerVersion: string): string[] | undefined;
/**
 * Ensure that the volume is in the correct format for the docker daemon on the host
 *
 * Windows: c:\path\to\volume -> /c/path/to/volume
 * Linux: /path/to/volume -> /path/to/volume
 * Mac: /path/to/volume -> /path/to/volume
 */
export declare function toLocalBindVolume(volume: string): string;
export declare const containerManager: ContainerManager;
export {};