import { P as NormalizedMeshConfig, W as NormalizedMeshServiceConfig, q as MeshInstanceRecord, u as MeshPodmanPlanOptions, t as MeshPodmanGenerateOptions } from '../types-C9VYURdP.js';
export { P as PodmanSupervisor } from '../PodmanSupervisor-C0mvIj-j.js';

interface PodmanContainerSpec {
    readonly id: string;
    readonly name: string;
    readonly image: string;
    readonly service: NormalizedMeshServiceConfig;
    readonly index: number;
    readonly hostPort: number | null;
    readonly containerPort: number | null;
    readonly logFile: string;
}
declare class PodmanCommandBuilder {
    private readonly config;
    constructor(config: NormalizedMeshConfig);
    networkExistsArgs(): readonly string[];
    createNetworkArgs(): readonly string[];
    runRedisArgs(): readonly string[];
    runServiceArgs(spec: PodmanContainerSpec): readonly string[];
    stopContainerArgs(containerName: string, timeoutSeconds: number): readonly string[];
    rmContainerArgs(containerName: string): readonly string[];
    buildRecord(spec: PodmanContainerSpec): MeshInstanceRecord;
    private buildEnv;
    private buildLabels;
}

declare class PodmanCommands {
    private readonly config;
    constructor(config: NormalizedMeshConfig);
    plan(options?: MeshPodmanPlanOptions): Promise<string>;
    generate(options?: MeshPodmanGenerateOptions): Promise<string>;
}

declare class PodmanPlan {
    private readonly config;
    private readonly ids;
    private readonly ports;
    private readonly logs;
    constructor(config: NormalizedMeshConfig);
    build(services?: NormalizedMeshServiceConfig[], instancesOverride?: number): Promise<readonly PodmanContainerSpec[]>;
    containerName(serviceName: string, index: number, id: string): string;
    private imageFor;
}

interface PodmanRunResult {
    readonly code: number;
    readonly stdout: string;
    readonly stderr: string;
}
declare class PodmanRunner {
    private readonly podmanPath;
    constructor(podmanPath: string);
    run(args: readonly string[], options?: {
        readonly allowFailure?: boolean;
    }): Promise<PodmanRunResult>;
}

interface QuadletFile {
    readonly name: string;
    readonly content: string;
}
declare class PodmanQuadletGenerator {
    private readonly config;
    constructor(config: NormalizedMeshConfig);
    generate(): Promise<readonly QuadletFile[]>;
    private networkFile;
    private redisFile;
    private serviceFile;
    private routerFile;
    private meshEnv;
    private routerConfigPath;
    private escape;
}

export { PodmanCommandBuilder, PodmanCommands, type PodmanContainerSpec, PodmanPlan, PodmanQuadletGenerator, type PodmanRunResult, PodmanRunner, type QuadletFile };