@usirin/spellcaster/dist/src/transport.d.ts

Remote execution of spells defined in spellbooks

import type { StandardSchemaV1 } from "@standard-schema/spec";
import { type Spellbook } from "@usirin/spellbook";
interface RequestSpec<TName extends keyof Spellbook["spells"] = keyof Spellbook["spells"]> {
    name: TName;
    parameters: StandardSchemaV1.InferInput<Spellbook["spells"][TName]["parameters"]>;
}
export declare const createRequest: (args_0: RequestSpec<string>) => import("@usirin/forge").Entity<"req"> & {
    name: string;
    parameters: any;
};
export type Request = ReturnType<typeof createRequest>;
interface ResponseSpec<TName extends keyof Spellbook["spells"] = keyof Spellbook["spells"]> {
    request: Request;
    result?: ReturnType<Spellbook["spells"][TName]["execute"]>;
    error?: {
        message: string;
        code?: string;
        details?: unknown;
    };
}
export declare const createResponse: (args_0: ResponseSpec<string>) => import("@usirin/forge").Entity<"resp"> & {
    request: import("@usirin/forge").Entity<"req"> & {
        name: string;
        parameters: any;
    };
    result: Promise<any> | undefined;
    error: {
        message: string;
        code?: string;
        details?: unknown;
    } | undefined;
};
export type Response = ReturnType<typeof createResponse>;
export declare function createSpellbookStream(spellbook: Spellbook): TransformStream<import("@usirin/forge").Entity<"req"> & {
    name: string;
    parameters: any;
}, import("@usirin/forge").Entity<"resp"> & {
    request: import("@usirin/forge").Entity<"req"> & {
        name: string;
        parameters: any;
    };
    result: Promise<any> | undefined;
    error: {
        message: string;
        code?: string;
        details?: unknown;
    } | undefined;
}>;
interface ServerTransportSpec {
    incoming: ReadableStream<Request>;
    outgoing: WritableStream<Response>;
}
export declare const createServerTransport: (args_0: ServerTransportSpec) => import("@usirin/forge").Entity<"xports"> & {
    incoming: ReadableStream<import("@usirin/forge").Entity<"req"> & {
        name: string;
        parameters: any;
    }>;
    outgoing: WritableStream<import("@usirin/forge").Entity<"resp"> & {
        request: import("@usirin/forge").Entity<"req"> & {
            name: string;
            parameters: any;
        };
        result: Promise<any> | undefined;
        error: {
            message: string;
            code?: string;
            details?: unknown;
        } | undefined;
    }>;
};
export type ServerTransport = ReturnType<typeof createServerTransport>;
interface ClientTransportSpec {
    incoming: ReadableStream<Response>;
    outgoing: WritableStream<Request>;
}
export declare const createClientTransport: (args_0: ClientTransportSpec) => import("@usirin/forge").Entity<"xportc"> & {
    incoming: ReadableStream<import("@usirin/forge").Entity<"resp"> & {
        request: import("@usirin/forge").Entity<"req"> & {
            name: string;
            parameters: any;
        };
        result: Promise<any> | undefined;
        error: {
            message: string;
            code?: string;
            details?: unknown;
        } | undefined;
    }>;
    outgoing: WritableStream<import("@usirin/forge").Entity<"req"> & {
        name: string;
        parameters: any;
    }>;
};
export type ClientTransport = ReturnType<typeof createClientTransport>;
export {};
//# sourceMappingURL=transport.d.ts.map