import type { PersistentVolume, VolumeAttachment, VolumeCapabilities, VolumeDriver, VolumeDriverObservation, VolumeSnapshot } from './model';
export interface DockerVolumeCommandResult {
    code: number;
    stdout: string;
    stderr: string;
}
export type DockerVolumeCommand = (args: string[]) => Promise<DockerVolumeCommandResult>;
export declare class DockerNamedVolumeDriver implements VolumeDriver {
    private readonly command;
    readonly provider = "docker";
    readonly type: 'docker';
    constructor(command?: DockerVolumeCommand);
    capabilities(): VolumeCapabilities;
    private run;
    private inspect;
    discover(_projectId?: string, _environmentId?: string): Promise<VolumeDriverObservation[]>;
    create(volume: PersistentVolume): Promise<VolumeDriverObservation>;
    attach(_volume: PersistentVolume, _attachment: VolumeAttachment): Promise<void>;
    detach(_volume: PersistentVolume, _attachment: VolumeAttachment): Promise<void>;
    resize(): Promise<VolumeDriverObservation>;
    snapshot(): Promise<{
        providerId?: string;
        sizeBytes?: number;
        checksum?: string;
    }>;
    restore(_volume: PersistentVolume, _snapshot: VolumeSnapshot, _target: PersistentVolume): Promise<VolumeDriverObservation>;
    delete(volume: PersistentVolume): Promise<void>;
    usage(volume: PersistentVolume): Promise<{
        usedBytes?: number;
        capacityBytes?: number;
    }>;
}
export declare class ServerPathVolumeDriver implements VolumeDriver {
    readonly provider = "server";
    readonly type: 'server_path';
    private readonly root;
    constructor(root: string);
    capabilities(): VolumeCapabilities;
    private path;
    discover(_projectId?: string, _environmentId?: string): Promise<VolumeDriverObservation[]>;
    create(volume: PersistentVolume): Promise<VolumeDriverObservation>;
    attach(_volume: PersistentVolume, _attachment: VolumeAttachment): Promise<void>;
    detach(_volume: PersistentVolume, _attachment: VolumeAttachment): Promise<void>;
    resize(): Promise<VolumeDriverObservation>;
    snapshot(): Promise<{
        providerId?: string;
        sizeBytes?: number;
        checksum?: string;
    }>;
    restore(_volume: PersistentVolume, _snapshot: VolumeSnapshot, _target: PersistentVolume): Promise<VolumeDriverObservation>;
    delete(volume: PersistentVolume): Promise<void>;
    usage(volume: PersistentVolume): Promise<{
        usedBytes?: number;
        capacityBytes?: number;
    }>;
}
export interface CloudVolumeTransport {
    list(projectId: string, environmentId?: string): Promise<VolumeDriverObservation[]>;
    create(input: {
        name: string;
        projectId: string;
        environmentId?: string;
        capacityBytes?: number;
        encrypted: boolean;
        filesystem?: string;
    }): Promise<VolumeDriverObservation>;
    attach(providerId: string, resourceProviderId: string, targetPath: string, readOnly: boolean): Promise<void>;
    detach(providerId: string, resourceProviderId: string, force: boolean): Promise<void>;
    resize(providerId: string, capacityBytes: number): Promise<VolumeDriverObservation>;
    snapshot(providerId: string, name: string): Promise<{
        providerId?: string;
        sizeBytes?: number;
        checksum?: string;
    }>;
    restore(providerId: string, snapshotProviderId: string, targetName: string): Promise<VolumeDriverObservation>;
    delete(providerId: string): Promise<void>;
    usage(providerId: string): Promise<{
        usedBytes?: number;
        capacityBytes?: number;
    }>;
}
export declare class CloudBlockVolumeDriver implements VolumeDriver {
    readonly provider: string;
    private readonly transport;
    readonly type: 'ebs';
    constructor(provider: string, transport: CloudVolumeTransport);
    capabilities(): VolumeCapabilities;
    discover(projectId: string, environmentId?: string): Promise<VolumeDriverObservation[]>;
    create(volume: PersistentVolume): Promise<VolumeDriverObservation>;
    private resource;
    attach(volume: PersistentVolume, attachment: VolumeAttachment): Promise<void>;
    detach(volume: PersistentVolume, attachment: VolumeAttachment, options: {
        force: boolean;
    }): Promise<void>;
    resize(volume: PersistentVolume, capacityBytes: number): Promise<VolumeDriverObservation>;
    snapshot(volume: PersistentVolume, snapshot: VolumeSnapshot): Promise<{
        providerId?: string;
        sizeBytes?: number;
        checksum?: string;
    }>;
    restore(volume: PersistentVolume, snapshot: VolumeSnapshot, target: PersistentVolume): Promise<VolumeDriverObservation>;
    delete(volume: PersistentVolume): Promise<void>;
    usage(volume: PersistentVolume): Promise<{
        usedBytes?: number;
        capacityBytes?: number;
    }>;
}
