@cavi-ai/api-client/core/transport/node

export declare function createStdioTransport(options: StdioTransportOptions): TransportByteChannel & Readonly<{
    closed: Promise<void>;
}>;

export declare function createUnixSocketTransport(options: UnixSocketTransportOptions): TransportByteChannel & Readonly<{
    ready: Promise<void>;
    closed: Promise<void>;
}>;

export interface StdioChildLike {
    readonly stdin: {
        write(chunk: Uint8Array): boolean;
        end(): void;
        once(event: "drain", listener: () => void): void;
    };
    readonly stdout: {
        on(event: "data", listener: (chunk: Uint8Array) => void): void;
    };
    readonly stderr: {
        on(event: "data", listener: (chunk: Uint8Array) => void): void;
    } | null;
    once(event: "error" | "exit", listener: (...args: unknown[]) => void): void;
    kill(signal?: string): boolean;
}

export type StdioSpawn = (command: string, args: readonly string[], options: {
    cwd?: string;
    env?: Readonly<Record<string, string>>;
}) => StdioChildLike;

export type StdioTransportOptions = Readonly<{
    command: string;
    args?: readonly string[];
    cwd?: string;
    env?: Readonly<Record<string, string>>;
    stderr?: "ignore" | "inherit" | ((chunk: Uint8Array) => void);
    signal?: AbortSignal;
    spawnImpl?: StdioSpawn;
}>;

export type UnixSocketConnect = (path: string) => UnixSocketLike;

export interface UnixSocketLike {
    write(chunk: Uint8Array): boolean;
    end(): void;
    destroy(error?: Error): void;
    on(event: "connect" | "drain" | "end" | "close", listener: () => void): void;
    on(event: "data", listener: (chunk: Uint8Array) => void): void;
    on(event: "error", listener: (error: Error) => void): void;
}

export type UnixSocketTransportOptions = Readonly<{
    path: string;
    reconnect?: TransportReconnectPolicy;
    signal?: AbortSignal;
    connectImpl?: UnixSocketConnect;
    dependencies?: Partial<TransportDependencies>;
}>;