@chord-ts/rpc/dist/server/index.d.ts

💎 Cutting edge transport framework vanishing borders between frontend and backend

import 'reflect-metadata';
import type { ComposerConfig, MethodDescription, PartialMethodDescription, PropertyDescription, Target, Schema, PropKey, Middleware, MethodConfig, Composed, Context } from './types';
import type * as JSONRPC from '../specs';
export declare class Composer<T extends {
    [k: string]: object;
}> {
    private config;
    private models;
    private middlewares;
    private adapter;
    constructor(models: T, config?: ComposerConfig);
    static readonly methods: Map<string, MethodDescription>;
    static readonly props: Map<string, PropertyDescription[]>;
    static init<T extends {
        [k: string]: object;
    }, Ctx extends Context>(models: T, config?: ComposerConfig): Composed<T>;
    static upsertMethod(desc: PartialMethodDescription): void;
    static addProp({ key, target }: {
        key: PropKey;
        target: object;
    }): void;
    get clientType(): T;
    use<Ev, Ctx, Ext>(middleware: Middleware<Ev, Ctx, Ext>): void;
    createScoped(ctx: unknown): T;
    get stringified(): T;
    getSchema(route?: string): Schema;
    private initCtx;
    exec<T extends object>(event: T): Promise<JSONRPC.SomeResponse<any> | JSONRPC.BatchResponse<any>>;
    private runMiddlewares;
    private execProcedure;
}
export declare function toRPC<T extends object>(instance: T): T;
export declare function rpc(config?: MethodConfig): (target: Target, key: PropKey, descriptor: PropertyDescriptor) => void;
export declare function depends(): (target: object, key: PropKey) => void;
export declare function val(validator: unknown): (target: Object, key: string | symbol, parameterIndex: number) => void;
//# sourceMappingURL=index.d.ts.map