@cybermp/rpc-router 0.1.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CyberMP-RPC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/client/index.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+const definitions = require('@cybermp/rpc-core/definitions');
+const utils = require('@cybermp/rpc-core/utils');
+
+const parseClientRest = (...args) => {
+  let player;
+  let data;
+  let meta;
+  let options;
+  if (utils.CURRENT_ENVIRONMENT === definitions.MpEnv.SERVER) {
+    [player, data, meta, options] = args;
+  } else {
+    [data, meta, options] = args;
+  }
+  return { player, data, meta, options };
+};
+const createRouterClient = (options) => {
+  const path = options.path ?? [];
+  const { rpc, target: targetEnv } = options;
+  const triggerClient = (...args) => {
+    const { data = {}, meta = {}, player } = parseClientRest(...args);
+    rpc.trigger(
+      new definitions.RpcPacket(
+        {
+          type: definitions.RpcPacketType.TRIGGER,
+          method: path.join("."),
+          data,
+          meta: { ...meta, router: true }
+        },
+        { target: targetEnv }
+      ),
+      player
+    );
+  };
+  const callClient = (...args) => {
+    const {
+      data = {},
+      meta = {},
+      options: callOptions = {},
+      player
+    } = parseClientRest(...args);
+    return rpc.call(
+      new definitions.RpcPacket(
+        {
+          type: definitions.RpcPacketType.CALL,
+          method: path.join("."),
+          data,
+          meta: { ...meta, router: true }
+        },
+        { target: targetEnv }
+      ),
+      callOptions,
+      player
+    );
+  };
+  return new Proxy(
+    {
+      trigger: triggerClient,
+      call: callClient
+    },
+    {
+      get(target, key) {
+        if (key === "call" || key === "trigger") {
+          return Reflect.get(target, key);
+        }
+        return createRouterClient({
+          ...options,
+          path: [...path, key]
+        });
+      }
+    }
+  );
+};
+
+exports.createRouterClient = createRouterClient;

package/dist/client/index.d.cts

@@ -0,0 +1,34 @@
+import { CallOptions, RpcBase } from '@cybermp/rpc-core';
+import { MpEnv, RpcApplyType } from '@cybermp/rpc-core/definitions';
+import { k as RouterOrProcedure, n as ContractProcedure, I as InferSchemaInput, b as InferSchemaOutput, R as Router } from '../shared/rpc-router.Cu7hweRg.cjs';
+
+type ClientReturn<TOutput, TMethod extends RpcApplyType> = TMethod extends RpcApplyType.ON ? void : Promise<TOutput>;
+type ClientRest<TInput, TMethod extends RpcApplyType, TEnv extends MpEnv, TPlayer = number> = [
+    ...(TEnv extends MpEnv.SERVER ? [player: TPlayer] : []),
+    ...[
+        ...(undefined extends TInput ? [data?: TInput] : [data: TInput]),
+        meta?: Record<string, any>,
+        ...(TMethod extends RpcApplyType.ON ? [] : [options?: CallOptions])
+    ]
+];
+type Client<TInput, TOutput, TMethod extends RpcApplyType, TEnv extends MpEnv, TPlayer = number> = TMethod extends RpcApplyType.ON ? {
+    trigger: (...args: ClientRest<TInput, TMethod, TEnv, TPlayer>) => ClientReturn<TOutput, TMethod>;
+} : {
+    call: (...args: ClientRest<TInput, TMethod, TEnv, TPlayer>) => ClientReturn<TOutput, TMethod>;
+};
+type NestedClient = Client<any, any, RpcApplyType, MpEnv, any> | {
+    [k: string]: NestedClient;
+};
+type RouterClient<TRouter extends RouterOrProcedure, TEnv extends MpEnv, TPlayer = number> = TRouter extends ContractProcedure<infer UInput, infer UOutput, infer UMethod> ? Client<InferSchemaInput<UInput>, InferSchemaOutput<UOutput>, UMethod, TEnv, TPlayer> : {
+    [K in keyof TRouter]: TRouter[K] extends RouterOrProcedure ? RouterClient<TRouter[K], TEnv, TPlayer> : never;
+};
+
+type RouterClientOptions<TTargetEnv extends MpEnv> = {
+    target: TTargetEnv;
+    rpc: RpcBase<any>;
+    path?: readonly string[];
+};
+declare const createRouterClient: <R extends Router, TSourceEnv extends MpEnv, TTargetEnv extends MpEnv, TPlayer = number>(options: RouterClientOptions<TTargetEnv>) => RouterClient<R, TSourceEnv, TPlayer>;
+
+export { createRouterClient };
+export type { Client, ClientRest, NestedClient, RouterClient };

package/dist/client/index.d.mts

@@ -0,0 +1,34 @@
+import { CallOptions, RpcBase } from '@cybermp/rpc-core';
+import { MpEnv, RpcApplyType } from '@cybermp/rpc-core/definitions';
+import { k as RouterOrProcedure, n as ContractProcedure, I as InferSchemaInput, b as InferSchemaOutput, R as Router } from '../shared/rpc-router.Cu7hweRg.mjs';
+
+type ClientReturn<TOutput, TMethod extends RpcApplyType> = TMethod extends RpcApplyType.ON ? void : Promise<TOutput>;
+type ClientRest<TInput, TMethod extends RpcApplyType, TEnv extends MpEnv, TPlayer = number> = [
+    ...(TEnv extends MpEnv.SERVER ? [player: TPlayer] : []),
+    ...[
+        ...(undefined extends TInput ? [data?: TInput] : [data: TInput]),
+        meta?: Record<string, any>,
+        ...(TMethod extends RpcApplyType.ON ? [] : [options?: CallOptions])
+    ]
+];
+type Client<TInput, TOutput, TMethod extends RpcApplyType, TEnv extends MpEnv, TPlayer = number> = TMethod extends RpcApplyType.ON ? {
+    trigger: (...args: ClientRest<TInput, TMethod, TEnv, TPlayer>) => ClientReturn<TOutput, TMethod>;
+} : {
+    call: (...args: ClientRest<TInput, TMethod, TEnv, TPlayer>) => ClientReturn<TOutput, TMethod>;
+};
+type NestedClient = Client<any, any, RpcApplyType, MpEnv, any> | {
+    [k: string]: NestedClient;
+};
+type RouterClient<TRouter extends RouterOrProcedure, TEnv extends MpEnv, TPlayer = number> = TRouter extends ContractProcedure<infer UInput, infer UOutput, infer UMethod> ? Client<InferSchemaInput<UInput>, InferSchemaOutput<UOutput>, UMethod, TEnv, TPlayer> : {
+    [K in keyof TRouter]: TRouter[K] extends RouterOrProcedure ? RouterClient<TRouter[K], TEnv, TPlayer> : never;
+};
+
+type RouterClientOptions<TTargetEnv extends MpEnv> = {
+    target: TTargetEnv;
+    rpc: RpcBase<any>;
+    path?: readonly string[];
+};
+declare const createRouterClient: <R extends Router, TSourceEnv extends MpEnv, TTargetEnv extends MpEnv, TPlayer = number>(options: RouterClientOptions<TTargetEnv>) => RouterClient<R, TSourceEnv, TPlayer>;
+
+export { createRouterClient };
+export type { Client, ClientRest, NestedClient, RouterClient };

package/dist/client/index.d.ts

@@ -0,0 +1,34 @@
+import { CallOptions, RpcBase } from '@cybermp/rpc-core';
+import { MpEnv, RpcApplyType } from '@cybermp/rpc-core/definitions';
+import { k as RouterOrProcedure, n as ContractProcedure, I as InferSchemaInput, b as InferSchemaOutput, R as Router } from '../shared/rpc-router.Cu7hweRg.js';
+
+type ClientReturn<TOutput, TMethod extends RpcApplyType> = TMethod extends RpcApplyType.ON ? void : Promise<TOutput>;
+type ClientRest<TInput, TMethod extends RpcApplyType, TEnv extends MpEnv, TPlayer = number> = [
+    ...(TEnv extends MpEnv.SERVER ? [player: TPlayer] : []),
+    ...[
+        ...(undefined extends TInput ? [data?: TInput] : [data: TInput]),
+        meta?: Record<string, any>,
+        ...(TMethod extends RpcApplyType.ON ? [] : [options?: CallOptions])
+    ]
+];
+type Client<TInput, TOutput, TMethod extends RpcApplyType, TEnv extends MpEnv, TPlayer = number> = TMethod extends RpcApplyType.ON ? {
+    trigger: (...args: ClientRest<TInput, TMethod, TEnv, TPlayer>) => ClientReturn<TOutput, TMethod>;
+} : {
+    call: (...args: ClientRest<TInput, TMethod, TEnv, TPlayer>) => ClientReturn<TOutput, TMethod>;
+};
+type NestedClient = Client<any, any, RpcApplyType, MpEnv, any> | {
+    [k: string]: NestedClient;
+};
+type RouterClient<TRouter extends RouterOrProcedure, TEnv extends MpEnv, TPlayer = number> = TRouter extends ContractProcedure<infer UInput, infer UOutput, infer UMethod> ? Client<InferSchemaInput<UInput>, InferSchemaOutput<UOutput>, UMethod, TEnv, TPlayer> : {
+    [K in keyof TRouter]: TRouter[K] extends RouterOrProcedure ? RouterClient<TRouter[K], TEnv, TPlayer> : never;
+};
+
+type RouterClientOptions<TTargetEnv extends MpEnv> = {
+    target: TTargetEnv;
+    rpc: RpcBase<any>;
+    path?: readonly string[];
+};
+declare const createRouterClient: <R extends Router, TSourceEnv extends MpEnv, TTargetEnv extends MpEnv, TPlayer = number>(options: RouterClientOptions<TTargetEnv>) => RouterClient<R, TSourceEnv, TPlayer>;
+
+export { createRouterClient };
+export type { Client, ClientRest, NestedClient, RouterClient };

package/dist/client/index.mjs

@@ -0,0 +1,74 @@
+import { RpcPacket, RpcPacketType, MpEnv } from '@cybermp/rpc-core/definitions';
+import { CURRENT_ENVIRONMENT } from '@cybermp/rpc-core/utils';
+
+const parseClientRest = (...args) => {
+  let player;
+  let data;
+  let meta;
+  let options;
+  if (CURRENT_ENVIRONMENT === MpEnv.SERVER) {
+    [player, data, meta, options] = args;
+  } else {
+    [data, meta, options] = args;
+  }
+  return { player, data, meta, options };
+};
+const createRouterClient = (options) => {
+  const path = options.path ?? [];
+  const { rpc, target: targetEnv } = options;
+  const triggerClient = (...args) => {
+    const { data = {}, meta = {}, player } = parseClientRest(...args);
+    rpc.trigger(
+      new RpcPacket(
+        {
+          type: RpcPacketType.TRIGGER,
+          method: path.join("."),
+          data,
+          meta: { ...meta, router: true }
+        },
+        { target: targetEnv }
+      ),
+      player
+    );
+  };
+  const callClient = (...args) => {
+    const {
+      data = {},
+      meta = {},
+      options: callOptions = {},
+      player
+    } = parseClientRest(...args);
+    return rpc.call(
+      new RpcPacket(
+        {
+          type: RpcPacketType.CALL,
+          method: path.join("."),
+          data,
+          meta: { ...meta, router: true }
+        },
+        { target: targetEnv }
+      ),
+      callOptions,
+      player
+    );
+  };
+  return new Proxy(
+    {
+      trigger: triggerClient,
+      call: callClient
+    },
+    {
+      get(target, key) {
+        if (key === "call" || key === "trigger") {
+          return Reflect.get(target, key);
+        }
+        return createRouterClient({
+          ...options,
+          path: [...path, key]
+        });
+      }
+    }
+  );
+};
+
+export { createRouterClient };

package/dist/server/index.cjs

@@ -0,0 +1,295 @@
+'use strict';
+
+const definitions = require('@cybermp/rpc-core/definitions');
+const radash = require('radash');
+
+class ProcedureBuilder {
+  "~crpc";
+  constructor(def) {
+    this["~crpc"] = def;
+  }
+  context() {
+    return new ProcedureBuilder(
+      this["~crpc"]
+    );
+  }
+  input(schema) {
+    return new ProcedureBuilder({
+      ...this["~crpc"],
+      inputSchema: schema
+    });
+  }
+  output(schema) {
+    return new ProcedureBuilder({
+      ...this["~crpc"],
+      outputSchema: schema
+    });
+  }
+  method(method) {
+    return new ProcedureBuilder({
+      ...this["~crpc"],
+      method
+    });
+  }
+  handler(...handler) {
+    return new Procedure({
+      ...this["~crpc"],
+      handler
+    });
+  }
+}
+const procedure = new ProcedureBuilder({ method: definitions.RpcApplyType.ON });
+
+class Procedure {
+  "~crpc";
+  constructor(def) {
+    this["~crpc"] = def;
+  }
+}
+function isProcedure(item) {
+  if (item instanceof Procedure) {
+    return true;
+  }
+  return (typeof item === "object" || typeof item === "function") && item !== null && "~crpc" in item && typeof item["~crpc"] === "object" && item["~crpc"] !== null && "handler" in item["~crpc"];
+}
+
+class ContractBuilder {
+  "~crpc";
+  constructor(def) {
+    this["~crpc"] = def;
+  }
+  input(schema) {
+    return new ContractBuilder({
+      ...this["~crpc"],
+      inputSchema: schema
+    });
+  }
+  output(schema) {
+    return new ContractBuilder({
+      ...this["~crpc"],
+      outputSchema: schema
+    });
+  }
+  method(method) {
+    return new ContractBuilder({
+      ...this["~crpc"],
+      method
+    });
+  }
+  build() {
+    return new Contract(this["~crpc"]);
+  }
+  implement(...handler) {
+    return new Procedure({
+      ...this["~crpc"],
+      handler
+    });
+  }
+}
+const contract = new ContractBuilder({ method: definitions.RpcApplyType.ON });
+
+class Contract {
+  "~crpc";
+  constructor(def) {
+    this["~crpc"] = def;
+  }
+}
+function isContract(item) {
+  if (item instanceof Contract) {
+    return true;
+  }
+  return (typeof item === "object" || typeof item === "function") && item !== null && "~crpc" in item && typeof item["~crpc"] === "object" && item["~crpc"] !== null && !("handler" in item["~crpc"]);
+}
+
+class RpcRouter {
+  constructor(rpc, options) {
+    this.rpc = rpc;
+    this.options = options;
+    this.registerGlobalMiddleware();
+  }
+  contract = new ContractBuilder({
+    method: definitions.RpcApplyType.ON
+  });
+  procedure = new ProcedureBuilder({
+    method: definitions.RpcApplyType.ON
+  });
+  store = {};
+  contractProcedureMap = /* @__PURE__ */ new WeakMap();
+  async validateSchema(schema, value) {
+    const result = await schema["~standard"].validate(value);
+    if (result.issues) {
+      throw definitions.RpcError.invalidData({
+        message: `Validation failed at ${result.issues.map((i) => i.message).join(", ")}`,
+        data: {
+          issues: result.issues
+        }
+      });
+    }
+    return result.value;
+  }
+  shouldValidate(key) {
+    const v = this.options?.validation;
+    if (typeof v === "boolean" && v) {
+      return true;
+    }
+    if (typeof v === "object") {
+      return !!v?.[key];
+    }
+    return false;
+  }
+  registerGlobalMiddleware() {
+    this.rpc.use(async (ctx, next) => {
+      if (!ctx.meta.router) {
+        return next?.();
+      }
+      const procedureContext = ctx;
+      const procedure = this.store[ctx.packet.method];
+      if (!procedure || !isProcedure(procedure)) {
+        return next?.();
+      }
+      procedureContext.procedure = procedure;
+      const def = procedure["~crpc"];
+      if (def.inputSchema && this.shouldValidate("input")) {
+        procedureContext.data = await this.validateSchema(
+          def.inputSchema,
+          procedureContext.data
+        );
+      }
+      if (procedureContext.packet.type === definitions.RpcPacketType.TRIGGER) {
+        return next?.();
+      }
+      const result = await next?.();
+      if (def.outputSchema && this.shouldValidate("output")) {
+        const validatedResult = await this.validateSchema(
+          def.outputSchema,
+          result
+        );
+        return validatedResult;
+      }
+      return result;
+    });
+  }
+  apply(router) {
+    for (const [name, procedure] of Object.entries(this.store)) {
+      delete this.store[name];
+      if (isContract(procedure)) {
+        continue;
+      }
+      this.removeProcedure(name, procedure);
+    }
+    const flatRouter = radash.crush(router);
+    for (const [name, procedure] of Object.entries(flatRouter)) {
+      this.store[name] = procedure;
+      if (isContract(procedure)) {
+        continue;
+      }
+      this.applyProcedure(name, procedure);
+    }
+  }
+  findNameByProcedureOrContract(c) {
+    for (const [key, value] of Object.entries(this.store)) {
+      if (value === c) {
+        return key;
+      }
+    }
+    return null;
+  }
+  implement(contractOrTree, ...handlerOrTree) {
+    const [zeroHandler] = handlerOrTree;
+    if (isContract(contractOrTree) && typeof zeroHandler !== "object") {
+      this.implementContract(contractOrTree, ...handlerOrTree);
+      return;
+    }
+    this.implementContractTree(contractOrTree, zeroHandler);
+  }
+  implementContract(contract, ...handler) {
+    if (!isContract(contract)) {
+      return;
+    }
+    const name = this.findNameByProcedureOrContract(contract);
+    if (!name) {
+      return;
+    }
+    const proc = new Procedure({
+      ...contract["~crpc"],
+      handler
+    });
+    this.contractProcedureMap.set(contract, proc);
+    this.store[name] = proc;
+    this.applyProcedure(name, proc);
+  }
+  implementContractTree(contractTree, handlerTree) {
+    for (const [key, contract] of Object.entries(contractTree)) {
+      const handler = handlerTree[key];
+      if (!handler) {
+        continue;
+      }
+      if (isContract(contract) && (Array.isArray(handler) || typeof handler === "function")) {
+        this.implementContract(
+          contract,
+          ...Array.isArray(handler) ? handler : [handler]
+        );
+      } else if (typeof contract === "object" && typeof handler === "object") {
+        this.implementContractTree(
+          contract,
+          handler
+        );
+      }
+    }
+  }
+  unimplement(contract) {
+    if (isContract(contract)) {
+      this.unimplementContract(contract);
+      return;
+    }
+    this.unimplementContractTree(contract);
+  }
+  unimplementContract(contract) {
+    const proc = this.contractProcedureMap.get(contract);
+    if (!proc) {
+      return;
+    }
+    const name = this.findNameByProcedureOrContract(proc);
+    if (!name) {
+      return;
+    }
+    this.store[name] = contract;
+    this.contractProcedureMap.delete(contract);
+    this.removeProcedure(name, proc);
+  }
+  unimplementContractTree(contractTree) {
+    for (const contract of Object.values(contractTree)) {
+      if (isContract(contract)) {
+        this.unimplementContract(contract);
+      } else {
+        this.unimplementContractTree(contract);
+      }
+    }
+  }
+  removeProcedure(name, procedure) {
+    const def = procedure["~crpc"];
+    if (def.method === definitions.RpcApplyType.REGISTER) {
+      this.rpc.unregister(name);
+    } else if (def.method === definitions.RpcApplyType.ON) {
+      this.rpc.offAll(name);
+    }
+  }
+  applyProcedure(name, procedure) {
+    const def = procedure["~crpc"];
+    if (def.method === definitions.RpcApplyType.REGISTER) {
+      this.rpc.register(name, ...def.handler);
+    } else if (def.method === definitions.RpcApplyType.ON) {
+      this.rpc.on(name, ...def.handler);
+    }
+  }
+}
+
+exports.Contract = Contract;
+exports.ContractBuilder = ContractBuilder;
+exports.Procedure = Procedure;
+exports.ProcedureBuilder = ProcedureBuilder;
+exports.RpcRouter = RpcRouter;
+exports.contract = contract;
+exports.isContract = isContract;
+exports.isProcedure = isProcedure;
+exports.procedure = procedure;

package/dist/server/index.d.cts

@@ -0,0 +1,78 @@
+import { A as AnySchema, P as ProcedureDef, S as Schema, I as InferSchemaInput, a as ProcedureHandler, b as InferSchemaOutput, c as Procedure, C as ContractDef, d as Contract, e as AnyContract, R as Router, f as ContractRouter } from '../shared/rpc-router.Cu7hweRg.cjs';
+export { h as AnyProcedure, n as ContractProcedure, l as InferRouterInputs, m as InferRouterOutputs, g as ProcedureContext, k as RouterOrProcedure, i as isContract, j as isProcedure } from '../shared/rpc-router.Cu7hweRg.cjs';
+import { RpcBase } from '@cybermp/rpc-core';
+import { RpcContext, RpcApplyType } from '@cybermp/rpc-core/definitions';
+
+type OverrideRpcContext<T extends RpcContext, D = any, M extends Record<string, any> = Record<string, any>> = Omit<T, 'data' | 'meta'> & {
+    data: D;
+    meta: M;
+};
+
+interface ProcedureBuilderDef<TCurrentContext extends RpcContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TMethod extends RpcApplyType> extends Omit<ProcedureDef<TCurrentContext, TInputSchema, TOutputSchema, TMethod>, 'handler'> {
+}
+declare class ProcedureBuilder<TCurrentContext extends RpcContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TMethod extends RpcApplyType> {
+    '~crpc': ProcedureBuilderDef<TCurrentContext, TInputSchema, TOutputSchema, TMethod>;
+    constructor(def: ProcedureBuilderDef<TCurrentContext, TInputSchema, TOutputSchema, TMethod>);
+    context<UContext extends TCurrentContext>(): ProcedureBuilder<UContext, TInputSchema, TOutputSchema, TMethod>;
+    input<USchema extends AnySchema>(schema: USchema): ProcedureBuilder<TCurrentContext, USchema, TOutputSchema, TMethod>;
+    output<USchema extends AnySchema>(schema: USchema): ProcedureBuilder<TCurrentContext, TInputSchema, USchema, TMethod>;
+    method<UMethod extends RpcApplyType>(method: UMethod): ProcedureBuilder<TCurrentContext, TInputSchema, UMethod extends RpcApplyType.ON ? Schema<void> : TOutputSchema, UMethod>;
+    handler<UFuncOutput extends InferSchemaInput<TOutputSchema>>(...handler: ProcedureHandler<OverrideRpcContext<TCurrentContext, InferSchemaOutput<TInputSchema>>, UFuncOutput>[]): Procedure<TCurrentContext, TInputSchema, TOutputSchema extends {
+        initial?: true;
+    } ? Schema<UFuncOutput> : TOutputSchema, TMethod>;
+}
+declare const procedure: ProcedureBuilder<RpcContext<any, Record<string, any>>, Schema<unknown, unknown>, Schema<void>, RpcApplyType.ON>;
+
+interface ContractBuilderDef<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TMethod extends RpcApplyType> extends ContractDef<TInputSchema, TOutputSchema, TMethod> {
+}
+declare class ContractBuilder<TCurrentContext extends RpcContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TMethod extends RpcApplyType> {
+    '~crpc': ContractBuilderDef<TInputSchema, TOutputSchema, TMethod>;
+    constructor(def: ContractBuilderDef<TInputSchema, TOutputSchema, TMethod>);
+    input<USchema extends AnySchema>(schema: USchema): ContractBuilder<TCurrentContext, USchema, TOutputSchema, TMethod>;
+    output<USchema extends AnySchema>(schema: USchema): ContractBuilder<TCurrentContext, TInputSchema, USchema, TMethod>;
+    method<UMethod extends RpcApplyType>(method: UMethod): ContractBuilder<TCurrentContext, TInputSchema, UMethod extends RpcApplyType.ON ? Schema<void> : TOutputSchema, UMethod>;
+    build(): Contract<TInputSchema, TOutputSchema, TMethod>;
+    implement<UFuncOutput extends InferSchemaInput<TOutputSchema>>(...handler: ProcedureHandler<OverrideRpcContext<TCurrentContext, InferSchemaOutput<TInputSchema>>, UFuncOutput>[]): Procedure<TCurrentContext, TInputSchema, TOutputSchema extends {
+        initial?: true;
+    } ? Schema<UFuncOutput> : TOutputSchema, TMethod>;
+}
+declare const contract: ContractBuilder<RpcContext<any, Record<string, any>>, Schema<unknown, unknown>, Schema<void> & {
+    initial?: true;
+}, RpcApplyType.ON>;
+
+type RpcRouterOptions = {
+    validation?: boolean | {
+        input?: boolean;
+        output?: boolean;
+    };
+};
+type InferImplementHandler<TContext extends RpcContext, TContract> = TContract extends AnyContract ? ProcedureHandler<OverrideRpcContext<TContext, InferSchemaOutput<TContract['~crpc']['inputSchema']>>, InferSchemaOutput<TContract['~crpc']['outputSchema']>> : TContract extends Record<string, any> ? {
+    [K in keyof TContract]: InferImplementHandler<TContext, TContract[K]>[] | InferImplementHandler<TContext, TContract[K]>;
+} : never;
+declare class RpcRouter<Context extends RpcContext> {
+    private readonly rpc;
+    private readonly options?;
+    readonly contract: ContractBuilder<Context, any, Schema<void>, RpcApplyType.ON>;
+    readonly procedure: ProcedureBuilder<Context, any, Schema<void>, RpcApplyType.ON>;
+    private store;
+    private contractProcedureMap;
+    constructor(rpc: RpcBase<any>, options?: RpcRouterOptions | undefined);
+    private validateSchema;
+    private shouldValidate;
+    private registerGlobalMiddleware;
+    apply(router: Router): void;
+    private findNameByProcedureOrContract;
+    implement<T extends AnyContract>(contract: T, ...handler: InferImplementHandler<Context, T>[]): void;
+    implement<T extends ContractRouter>(contractTree: T, handlerTree: InferImplementHandler<Context, T>): void;
+    private implementContract;
+    private implementContractTree;
+    unimplement(contract: AnyContract): void;
+    unimplement(contractTree: ContractRouter): void;
+    private unimplementContract;
+    private unimplementContractTree;
+    private removeProcedure;
+    private applyProcedure;
+}
+
+export { AnyContract, Contract, ContractBuilder, ContractDef, ContractRouter, Procedure, ProcedureBuilder, ProcedureDef, ProcedureHandler, Router, RpcRouter, contract, procedure };
+export type { ContractBuilderDef, InferImplementHandler, ProcedureBuilderDef, RpcRouterOptions };