import { type Condition, type RequirementDefinition } from './deploy';
export interface BunProviderConfig {
    installScope: 'host';
}
export interface DockerProviderConfig {
    installScope: 'host';
    storageDriver: 'overlay2';
    dataRoot: string;
    liveRestore: boolean;
    logDriver: 'journald' | 'local';
    defaultNetwork: 'bridge';
    rootless: boolean;
}
export interface ContainerdProviderConfig {
    installScope: 'host';
    runtimeClass: 'runc';
    namespace: 'forgezero';
    snapshotter: 'overlayfs';
}
export interface KataProviderConfig {
    installScope: 'host';
    runtimeClass: 'kata-qemu-snp';
    namespace: 'forgezero';
    hypervisor: 'qemu';
    confidentialGuest: 'sev-snp';
}
export interface NginxProviderConfig {
    installScope: 'host';
    websocket: boolean;
    maximumBodyMiB: number;
    workerProcesses: 'auto' | number;
    workerConnections: number;
}
export interface ArangoDbProviderConfig {
    installScope: 'host';
    runtime: 'native';
    dataPath: string;
    bind: 'private';
}
export interface CloudflaredProviderConfig {
    installScope: 'host';
    mode: 'tunnel';
}
export interface WarpProviderConfig {
    installScope: 'host';
    mode: 'device' | 'mesh';
}
export interface UfwProviderConfig {
    installScope: 'host';
    defaultIncoming: 'deny';
    defaultOutgoing: 'allow';
}
export interface OpenSshProviderConfig {
    installScope: 'host';
    mode: 'client';
}
export interface SystemdProviderConfig {
    installScope: 'host';
    credentials: 'encrypted';
    serviceSandbox: 'strict';
}
type RequirementOptions<T> = {
    version: string;
    config?: Partial<T>;
    when?: Condition;
};
export declare const providers: {
    readonly bun: {
        readonly require: (options?: RequirementOptions<BunProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
    };
    readonly docker: {
        readonly require: (options?: RequirementOptions<DockerProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
    };
    readonly containerd: {
        readonly require: (options?: RequirementOptions<ContainerdProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
    };
    readonly kata: {
        readonly require: (options?: RequirementOptions<KataProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
    };
    readonly nginx: {
        readonly require: (options?: RequirementOptions<NginxProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
    };
    readonly arangodb: {
        readonly require: (options?: RequirementOptions<ArangoDbProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
    };
    readonly cloudflared: {
        readonly require: (options?: RequirementOptions<CloudflaredProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
    };
    readonly warp: {
        readonly require: (options?: RequirementOptions<WarpProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
    };
    readonly ufw: {
        readonly require: (options?: RequirementOptions<UfwProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
    };
    readonly openssh: {
        readonly require: (options?: RequirementOptions<OpenSshProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
    };
    readonly systemd: {
        readonly require: (options?: RequirementOptions<SystemdProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
    };
};
/** Runtime validation for package-owned provider contracts; TypeScript is not a trust boundary. */
export declare function validateBuiltInProvider(requirement: RequirementDefinition, where: string): void;
export {};