akanjs 2.2.4 → 2.2.5

package/types/service/predefinedAdaptor/websocket.adaptor.d.ts

@@ -0,0 +1,49 @@
+import type { BaseEnv, Cls } from "akanjs/base";
+import { ProtobufCompressor } from "./compress.adaptor";
+export interface WsSocketData {
+    socketId?: string;
+    createdAt?: number;
+}
+export type WsRedisEventHandler = (roomId: string, data: unknown) => void;
+export interface WebsocketAdaptor {
+    /** Publish data to a room across all server instances */
+    publish(roomId: string, data: unknown): void;
+    /** Register an event handler for incoming cross-server messages */
+    setEventHandler(handler: WsRedisEventHandler): void;
+    /** Unregister the event handler */
+    clearEventHandler(): void;
+    /** Register endpoint return type info for protobuf encoding */
+    registerEndpoint(key: string, returnRef: Cls, arrDepth: number): void;
+    /** Register a socket joining a room (tracked in Redis for cross-server awareness) */
+    joinRoom(ws: Bun.ServerWebSocket<unknown>, room: string): Promise<void>;
+    /** Remove a socket from a room */
+    leaveRoom(ws: Bun.ServerWebSocket<unknown>, room: string): Promise<void>;
+    /** Remove a socket from all rooms and clean up its Redis state */
+    leaveAllRooms(ws: Bun.ServerWebSocket<unknown>): Promise<void>;
+    /** Register a socket connection on this server */
+    registerSocket(ws: Bun.ServerWebSocket<unknown>, meta?: Record<string, string>): Promise<void>;
+    /** Unregister a socket connection */
+    unregisterSocket(ws: Bun.ServerWebSocket<unknown>): Promise<void>;
+}
+declare const WebSocketRedisAdaptor_base: import("..").AdaptorCls<{}, {
+    redis: import("..").InjectInfo<"plug", import("ioredis").default, never, never>;
+    compressor: import("..").InjectInfo<"plug", ProtobufCompressor, never, never>;
+    serverId: import("..").InjectInfo<"env", string, BaseEnv, never>;
+    publisher: import("..").InjectInfo<"plug", import("ioredis").default, never, never>;
+    subscriber: import("..").InjectInfo<"plug", import("ioredis").default, never, never>;
+}>;
+export declare class WebSocketRedisAdaptor extends WebSocketRedisAdaptor_base implements WebsocketAdaptor {
+    #private;
+    onInit(): Promise<void>;
+    onDestroy(): Promise<void>;
+    publish(roomId: string, data: unknown): void;
+    setEventHandler(handler: WsRedisEventHandler): void;
+    clearEventHandler(): void;
+    registerEndpoint(key: string, returnRef: Cls, arrDepth: number): void;
+    joinRoom(ws: Bun.ServerWebSocket<unknown>, room: string): Promise<void>;
+    leaveRoom(ws: Bun.ServerWebSocket<unknown>, room: string): Promise<void>;
+    leaveAllRooms(ws: Bun.ServerWebSocket<unknown>): Promise<void>;
+    registerSocket(ws: Bun.ServerWebSocket<unknown>, meta?: Record<string, string>): Promise<void>;
+    unregisterSocket(ws: Bun.ServerWebSocket<unknown>): Promise<void>;
+}
+export {};

package/types/service/predefinedAdaptor.d.ts

@@ -0,0 +1 @@
+export * from "./predefinedAdaptor/index.d.ts";

package/types/service/serve.d.ts

@@ -0,0 +1,31 @@
+import { type Cls, INJECT_META } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import type { DatabaseModel, FilterInstance } from "akanjs/document";
+import { type ExtractInjectInfoObject, type InjectBuilder, InjectInfo } from "./injectInfo.d.ts";
+import type { DatabaseService } from "./types.d.ts";
+interface ServiceOptions {
+    enabled?: boolean;
+    serverMode?: "batch" | "federation";
+}
+export type ServiceType = "database" | "plain";
+export interface Service {
+    readonly logger: Logger;
+    onInit(): Promise<void>;
+    _libsOnInit(): Promise<void>;
+    onDestroy(): Promise<void>;
+    _libsOnDestroy(): Promise<void>;
+}
+export type ServiceCls<RefName extends string = string, Methods = {}, InjectMap extends {
+    [key: string]: InjectInfo;
+} = {}> = Cls<Methods & ExtractInjectInfoObject<InjectMap> & Service, {
+    readonly refName: RefName;
+    readonly type: ServiceType;
+    readonly [INJECT_META]: InjectMap;
+    readonly enabled: boolean;
+}>;
+export declare function serve<RefName extends string, Injection extends InjectBuilder>(refName: RefName, injectBuilder: Injection, ...extendSrvs: Cls[]): ServiceCls<RefName, {}, ReturnType<Injection>>;
+export declare function serve<RefName extends string, Injection extends InjectBuilder>(refName: RefName, option: ServiceOptions, injectBuilder: Injection, ...extendSrvs: Cls[]): ServiceCls<RefName, {}, ReturnType<Injection>>;
+export declare function serve<T extends string, Input, Doc, Model, Obj, Insight, Filter extends FilterInstance, Injection extends InjectBuilder, LibSrvs extends Cls[] = []>(db: DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter>, injectBuilder: Injection, ...extendSrvs: LibSrvs): ServiceCls<T, DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, LibSrvs>, ReturnType<Injection>>;
+export declare function serve<T extends string, Input, Doc, Model, Obj, Insight, Filter extends FilterInstance, Injection extends InjectBuilder, LibSrvs extends Cls[] = []>(db: DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter>, injectBuilder: Injection, ...extendSrvs: LibSrvs): ServiceCls<T, DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, LibSrvs>, ReturnType<Injection>>;
+export declare function serve<T extends string, Input, Doc, Model, Obj, Insight, Filter extends FilterInstance, Injection extends InjectBuilder, LibSrvs extends ServiceCls[] = []>(db: DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter>, option: ServiceOptions, injectBuilder: Injection, ...extendSrvs: LibSrvs): ServiceCls<T, DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, LibSrvs>, ReturnType<Injection>>;
+export {};

package/types/service/serviceModule.d.ts

@@ -0,0 +1,50 @@
+import type { MergeAllKeyOfObjects, PromiseOrObject, UnCls } from "akanjs/base";
+import type { ConstantModel, QueryOf } from "akanjs/constant";
+import type { CRUDEventType, DatabaseModel, DataInputOf, Doc, FindQueryOption, ListQueryOption, SaveEventType } from "akanjs/document";
+import type { ServiceCls } from "./serve.d.ts";
+import type { DatabaseService } from "./types.d.ts";
+export declare class ServiceModel<Srv extends ServiceCls = ServiceCls, CnstModel extends ConstantModel = any, DbModel extends DatabaseModel = any, SrvMap extends {
+    [key: string]: any;
+} = {
+    [K in `${Uncapitalize<Srv["refName"]>}Service`]: UnCls<Srv>;
+}> {
+    srv: Srv;
+    cnst: CnstModel;
+    db: DbModel;
+    srvMap: SrvMap;
+    constructor(srv: Srv, cnst?: CnstModel, db?: DbModel, srvMap?: {
+        [key: string]: ServiceCls;
+    });
+    static fromModel<Srv extends ServiceCls, CnstModel extends ConstantModel, DbModel extends DatabaseModel>(srv: Srv, cnst: CnstModel, db: DbModel): ServiceModel<Srv, CnstModel, DbModel>;
+    static from<Srv extends ServiceCls>(srv: Srv): ServiceModel<Srv, never, never, { [K in `${Uncapitalize<Srv["refName"]>}Service`]: UnCls<Srv>; }>;
+    with<SrvModules extends ServiceModel[]>(...srvs: SrvModules): ServiceModel<Srv, CnstModel, DbModel, SrvMap & MergeAllKeyOfObjects<SrvModules, "srvMap">>;
+    static getDefaultDbServiceMethods(className: string): {
+        [x: string]: ((this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) => Promise<any>) | ((this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) => Promise<any>) | ((this: DatabaseService, type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => any) | ((this: DatabaseService, id: string, data: DataInputOf) => Promise<any>);
+        __get(this: DatabaseService, id: string): Promise<any>;
+        __load(this: DatabaseService, id?: string): Promise<any>;
+        __loadMany(this: DatabaseService, ids: string[]): Promise<any>;
+        __list(this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption): Promise<any>;
+        __listIds(this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption): Promise<any>;
+        __find(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption): Promise<any>;
+        __findId(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption): Promise<any>;
+        __pick(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption): Promise<any>;
+        __pickId(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption): Promise<any>;
+        __exists(this: DatabaseService, query: QueryOf<any>): Promise<any>;
+        __count(this: DatabaseService, query: QueryOf<any>): Promise<any>;
+        __insight(this: DatabaseService, query: QueryOf<any>): Promise<any>;
+        _preCreate(this: DatabaseService, data: DataInputOf): Promise<DataInputOf>;
+        _postCreate(this: DatabaseService, doc: Doc): Promise<any>;
+        _preUpdate(this: DatabaseService, id: string, data: Partial<Doc>): Promise<Partial<any>>;
+        _postUpdate(this: DatabaseService, doc: Doc): Promise<any>;
+        _preRemove(this: DatabaseService, id: string): Promise<void>;
+        _postRemove(this: DatabaseService, doc: Doc): Promise<any>;
+        listenPre(this: DatabaseService, type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>): any;
+        listenPost(this: DatabaseService, type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>): any;
+        __create(this: DatabaseService, data: DataInputOf): Promise<any>;
+        __update(this: DatabaseService, id: string, data: DataInputOf): Promise<any>;
+        __remove(this: DatabaseService, id: string): Promise<Doc>;
+    };
+    static getFilterServiceMethods(queryKey: string, queryFn: (...args: any[]) => QueryOf<any>): {
+        [x: string]: (this: DatabaseService, ...args: any) => any;
+    };
+}

package/types/service/serviceRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { AdaptorCls } from "./adapt.d.ts";
+import type { ServiceCls } from "./serve.d.ts";
+export declare class ServiceRegistry {
+    #private;
+    static setDatabase(refName: string, service: ServiceCls): void;
+    static getDatabase(refName: string): ServiceCls | undefined;
+    static setPlain(refName: string, service: ServiceCls): void;
+    static setAdaptor(refName: string, adaptor: AdaptorCls): void;
+}

package/types/service/types.d.ts

@@ -0,0 +1,55 @@
+import type { Cls, MergeAllTypes, PromiseOrObject } from "akanjs/base";
+import type { Logger } from "akanjs/common";
+import type { QueryOf } from "akanjs/constant";
+import type { CRUDEventType, DatabaseInstance, DataInputOf, Doc as DbDoc, ExtractQuery, ExtractSort, FilterInstance, FindQueryOption, GetDocObject, ListQueryOption, QueryMethodPart, SaveEventType } from "akanjs/document";
+type ServiceMixinOmitKey = "onInit" | "onDestroy" | "_libsOnInit" | "_libsOnDestroy" | "_preCreate" | "_postCreate" | "_preUpdate" | "_postUpdate" | "_preRemove" | "_postRemove" | "_libsPreCreate" | "_libsPostCreate" | "_libsPreUpdate" | "_libsPostUpdate" | "_libsPreRemove" | "_libsPostRemove";
+export type DatabaseService<T extends string = string, Input = any, Doc = any, Obj = any, Model = any, Insight = any, Filter extends FilterInstance = FilterInstance, LibSrvs extends Cls[] = [], _Query extends ExtractQuery<Filter> = ExtractQuery<Filter>, _Sort extends ExtractSort<Filter> = ExtractSort<Filter>, _CapitalizedRefName extends Capitalize<T> = Capitalize<T>, _DataInputOfDoc extends DataInputOf<Input, Doc> = DataInputOf<Input, Doc>, _QueryOfDoc extends QueryOf<Doc> = QueryOf<Doc>, _FindQueryOption extends FindQueryOption<_Sort, Obj> = FindQueryOption<_Sort, Obj>, _ListQueryOption extends ListQueryOption<_Sort, Obj> = ListQueryOption<_Sort, Obj>, _DocObjectOfDoc = GetDocObject<Doc>, _MixedLibSrv = MergeAllTypes<LibSrvs, ServiceMixinOmitKey>> = {
+    logger: Logger;
+    __databaseModel: Model;
+    __get: (id: string) => Promise<Doc>;
+    __load: (id?: string) => Promise<Doc | null>;
+    __loadMany: (ids: string[]) => Promise<Doc[]>;
+    __create: (data: _DataInputOfDoc) => Promise<Doc>;
+    __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
+    __remove: (id: string) => Promise<Doc>;
+    __list(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;
+    __listIds(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<string[]>;
+    __find(query?: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc | null>;
+    __findId(query?: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<string | null>;
+    __pick(query?: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc>;
+    __pickId(query?: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<string>;
+    __exists(query?: _QueryOfDoc): Promise<string | null>;
+    __count(query?: _QueryOfDoc): Promise<number>;
+    __insight(query?: _QueryOfDoc): Promise<Insight>;
+    _preCreate?(data: _DataInputOfDoc): PromiseOrObject<_DataInputOfDoc>;
+    _postCreate?(doc: Doc): Promise<Doc> | Doc;
+    _preUpdate?(id: string, data: Partial<Doc>): PromiseOrObject<Partial<Doc>>;
+    _postUpdate?(doc: Doc): Promise<Doc> | Doc;
+    _preRemove?(id: string): Promise<void> | void;
+    _postRemove?(doc: Doc): Promise<Doc> | Doc;
+    __libsPreCreate: (data: _DataInputOfDoc) => Promise<_DataInputOfDoc>;
+    __libsPostCreate: (doc: Doc) => Promise<Doc>;
+    __libsPreUpdate: (id: string, data: Partial<Doc>) => Promise<Partial<Doc>>;
+    __libsPostUpdate: (doc: Doc) => Promise<Doc>;
+    __libsPreRemove: (id: string) => Promise<void>;
+    __libsPostRemove: (doc: Doc) => Promise<Doc>;
+    listenPre: (type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
+    listenPost: (type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
+} & {
+    [key in `${T}Model`]: Model;
+} & {
+    [K in `get${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
+} & {
+    [K in `load${_CapitalizedRefName}`]: (id?: string) => Promise<Doc | null>;
+} & {
+    [K in `load${_CapitalizedRefName}Many`]: (ids: string[]) => Promise<Doc[]>;
+} & {
+    [K in `create${_CapitalizedRefName}`]: (data: _DataInputOfDoc) => Promise<Doc>;
+} & {
+    [K in `update${_CapitalizedRefName}`]: (id: string, data: Partial<Doc>) => Promise<Doc>;
+} & {
+    [K in `remove${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
+} & QueryMethodPart<_Query, _Sort, Obj, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc> & {
+    [K in keyof _MixedLibSrv]: _MixedLibSrv[K] extends (...args: infer Args) => Promise<infer Value> ? Value extends (infer SingleValue)[] ? SingleValue extends DatabaseInstance ? _DocObjectOfDoc extends GetDocObject<SingleValue> ? (...args: Args) => Promise<Doc[]> : _MixedLibSrv[K] : _MixedLibSrv[K] : Value extends DbDoc<any> ? _DocObjectOfDoc extends GetDocObject<Value> ? (...args: Args) => Promise<Doc> : _MixedLibSrv[K] : _MixedLibSrv[K] : _MixedLibSrv[K];
+};
+export {};

package/types/service.d.ts

@@ -0,0 +1 @@
+export * from "./service/index.d.ts";

package/types/signal/base.signal.d.ts

@@ -0,0 +1,41 @@
+declare const BaseInternal_base: import("./internal.d.ts").InternalCls<import("akanjs/service").ServiceModel<typeof import("akanjs/service").BaseService, any, any, {
+    baseService: import("akanjs/service").BaseService;
+}>, {}>;
+export declare class BaseInternal extends BaseInternal_base {
+}
+declare const BaseEndpoint_base: import("./endpoint.d.ts").EndpointCls<import("akanjs/service").ServiceModel<typeof import("akanjs/service").BaseService, any, any, {
+    baseService: import("akanjs/service").BaseService;
+}>, {
+    ping: import("./endpointInfo.d.ts").EndpointInfo<"query", {
+        baseService: import("akanjs/service").BaseService;
+    }, [], [], [], [], StringConstructor, string, string, false>;
+    pingBody: import("./endpointInfo.d.ts").EndpointInfo<"mutation", {
+        baseService: import("akanjs/service").BaseService;
+    }, ["data"], [arg: string], [], [arg: string], StringConstructor, string, string, false>;
+    pingParam: import("./endpointInfo.d.ts").EndpointInfo<"query", {
+        baseService: import("akanjs/service").BaseService;
+    }, [string], [arg: string], [], [arg: string], StringConstructor, string, string, false>;
+    pingQuery: import("./endpointInfo.d.ts").EndpointInfo<"query", {
+        baseService: import("akanjs/service").BaseService;
+    }, [string], [arg?: string | null | undefined], [], [arg: string | undefined], StringConstructor, string, string, true>;
+    cleanup: import("./endpointInfo.d.ts").EndpointInfo<"mutation", {
+        baseService: import("akanjs/service").BaseService;
+    }, [], [], [], [], BooleanConstructor, boolean, Promise<boolean>, false>;
+    wsPing: import("./endpointInfo.d.ts").EndpointInfo<"message", {
+        baseService: import("akanjs/service").BaseService;
+    }, [string], [arg?: string | null | undefined], [], [arg: string | undefined], StringConstructor, string, string, false>;
+    pubsubPing: import("./endpointInfo.d.ts").EndpointInfo<"pubsub", {
+        baseService: import("akanjs/service").BaseService;
+    }, [], [], [], [], StringConstructor, string, void, false>;
+}>;
+export declare class BaseEndpoint extends BaseEndpoint_base {
+}
+declare const Base_base: import("./serverSignal.d.ts").ServerSignalCls<typeof BaseEndpoint, typeof BaseInternal>;
+export declare class Base extends Base_base {
+}
+export declare const base: import("./signalRegistry.d.ts").ServiceSignal<typeof BaseInternal, typeof BaseEndpoint, typeof Base>;
+export declare const fetch: import("akanjs/fetch").FetchProxy<import("../base.d.ts").Assign<unknown, import("akanjs/fetch").GetFetchTypeFromEndpoint<typeof BaseEndpoint>>, import("akanjs/fetch").GetSliceMetaObjFromDatabaseSignals<[import("./signalRegistry.d.ts").ServiceSignal<typeof BaseInternal, typeof BaseEndpoint, typeof Base>]>>;
+export declare const getSerializedSignal: () => {
+    [key: string]: import("./types.d.ts").SerializedSignal;
+};
+export {};

package/types/signal/endpoint.d.ts

@@ -0,0 +1,28 @@
+import type { Assign } from "akanjs/base";
+import { ENDPOINT_META } from "akanjs/base";
+import { type Adaptor, type AdaptorCls, type ServiceModel } from "akanjs/service";
+import { type EndpointBuilder, type EndpointInfo } from "./endpointInfo.d.ts";
+export interface Endpoint extends Adaptor {
+}
+export interface EndpointCls<SrvModule extends ServiceModel = ServiceModel, EndpointInfoObj extends {
+    [key: string]: EndpointInfo;
+} = {
+    [key: string]: EndpointInfo;
+}> extends AdaptorCls {
+    baseName: SrvModule["srv"]["refName"];
+    srv: SrvModule;
+    [ENDPOINT_META]: EndpointInfoObj;
+}
+type ExtendedEndpointReturn<ClientReturns, Full, Light, Insight> = ClientReturns extends (infer R)[] ? ExtendedEndpointReturn<R, Full, Light, Insight>[] : Full extends ClientReturns ? Full : Light extends ClientReturns ? Light : Insight extends ClientReturns ? Insight : ClientReturns;
+type EndpointMetaOf<EndpCls> = EndpCls extends EndpointCls<any, infer EndpointInfoObj> ? EndpointInfoObj : never;
+type MergeEndpointMetas<EndpClses extends readonly EndpointCls[], Acc = unknown> = EndpClses extends readonly [
+    infer First extends EndpointCls,
+    ...infer Rest extends readonly EndpointCls[]
+] ? MergeEndpointMetas<Rest, Assign<Acc, EndpointMetaOf<First>>> : Acc;
+type ExtendEndpoints<SrvModule extends ServiceModel, LibEndpoints extends readonly EndpointCls[], _Full = NonNullable<SrvModule["cnst"]>["_Full"], _Light = NonNullable<SrvModule["cnst"]>["_Light"], _Insight = NonNullable<SrvModule["cnst"]>["_Insight"], _Merged = MergeEndpointMetas<LibEndpoints>> = {
+    [K in keyof _Merged]: _Merged[K] extends EndpointInfo<infer ReqType, infer Srvs, infer ArgNames, infer Args, infer InternalArgs, infer ServerArgs, infer Returns, infer ClientReturns, infer ServerReturns, infer Nullable> ? EndpointInfo<ReqType, Srvs, ArgNames, Args, InternalArgs, ServerArgs, Returns, ExtendedEndpointReturn<ClientReturns, _Full, _Light, _Insight>, ServerReturns, Nullable> : never;
+};
+/** Builds a typed endpoint adaptor from a service module and endpoint builder. */
+export declare function endpoint<SrvModule extends ServiceModel, Builder extends EndpointBuilder<SrvModule>, LibEndpoints extends readonly EndpointCls[]>(srv: SrvModule, builder: Builder, ...libEndpoints: LibEndpoints): EndpointCls<SrvModule, LibEndpoints extends readonly [] ? ReturnType<Builder> : Assign<ReturnType<Builder>, ExtendEndpoints<SrvModule, LibEndpoints>>>;
+export declare function sliceEndpoint<SrvModule extends ServiceModel, Builder extends EndpointBuilder<SrvModule>>(srv: SrvModule, builder: Builder): EndpointCls<SrvModule, ReturnType<Builder>>;
+export {};

package/types/signal/endpointInfo.d.ts

@@ -0,0 +1,77 @@
+import { type Dayjs, type EnumInstance, type PromiseOrObject } from "akanjs/base";
+import type { ConstantFieldType, ConstantFieldTypeInput, DocumentModel, FieldToValue, ParamFieldType, PlainTypeToFieldType, PurifiedModel } from "akanjs/constant";
+import type { ServiceModel } from "akanjs/service";
+import type { InternalArgCls } from "./internalArg.d.ts";
+import type { ArgType, SignalOption } from "./types.d.ts";
+export type EndpointType = "query" | "mutation" | "pubsub" | "message";
+export interface EndpointArgProps<Optional extends boolean = false> {
+    nullable?: Optional;
+    example?: string | number | boolean | Dayjs;
+}
+export interface InternalArgProps<Optional extends boolean = false> {
+    nullable?: Optional;
+}
+export interface ReturnInfo<Returns extends ConstantFieldTypeInput = any, Nullable extends boolean = false> {
+    returnRef: Returns;
+    arrDepth: number;
+    enum?: EnumInstance;
+    nullable?: Nullable;
+}
+export interface ArgInfo<ArgProps = any> {
+    type: ArgType;
+    name: string;
+    argRef: ConstantFieldType;
+    arrDepth: number;
+    enum?: EnumInstance;
+    option?: ArgProps;
+}
+export interface InternalArgInfo<Optional extends boolean = false> {
+    argRef: InternalArgCls;
+    option?: InternalArgProps<Optional>;
+}
+export declare class EndpointInfo<ReqType extends EndpointType = EndpointType, Srvs extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}, ArgNames extends string[] = any, Args extends any[] = any, InternalArgs extends any[] = any, ServerArgs extends any[] = any, Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, ClientReturns = never, ServerReturns = never, Nullable extends boolean = boolean> {
+    readonly type: ReqType;
+    readonly argNames: ArgNames;
+    readonly args: ArgInfo<EndpointArgProps<boolean>>[];
+    readonly internalArgs: InternalArgInfo<boolean>[];
+    readonly returns: ReturnInfo<Returns, Nullable>;
+    readonly signalOption: SignalOption<Returns, Nullable, any>;
+    execFn: ((...args: [...ServerArgs, ...InternalArgs]) => PromiseOrObject<any>) | null;
+    static getArgInfo(type: ArgType, name: string, arg: ConstantFieldTypeInput, option?: EndpointArgProps<boolean>): ArgInfo;
+    static getReturnInfo<Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(modelRef: Returns, signalOption?: SignalOption<Returns, Nullable>): ReturnInfo<Returns, Nullable>;
+    constructor(type: ReqType, returnRef: Returns, signalOption?: SignalOption<Returns, Nullable>);
+    param<ArgName extends string, Arg extends ParamFieldType, _ClientArg = FieldToValue<Arg>, _ServerArg = DocumentModel<_ClientArg>>(name: string, arg: Arg, option?: Omit<EndpointArgProps, "nullable">): EndpointInfo<ReqType, Srvs, [...ArgNames, ArgName], [...Args, arg: _ClientArg], InternalArgs, [...ServerArgs, arg: _ServerArg], Returns, ClientReturns, ServerReturns, Nullable>;
+    body<ArgName extends string, ExplicitType = unknown, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, Optional extends boolean = false, _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType, _ClientArg = PurifiedModel<_ArgType>, _ServerArg = DocumentModel<_ArgType>>(name: ArgName, arg: Arg, option?: EndpointArgProps<Optional>): EndpointInfo<ReqType, Srvs, [...ArgNames, ArgName], Optional extends true ? [...Args, arg?: _ClientArg | null] : [...Args, arg: _ClientArg], InternalArgs, [...ServerArgs, arg: _ServerArg | (Optional extends true ? undefined : never)], Returns, ClientReturns, ServerReturns, Nullable>;
+    room<ArgName extends string, ExplicitType = unknown, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType, _ClientArg = PurifiedModel<_ArgType>, _ServerArg = DocumentModel<_ArgType>>(name: string, arg: Arg, option?: Omit<EndpointArgProps, "nullable">): EndpointInfo<ReqType, Srvs, [...ArgNames, ArgName], [...Args, arg: _ClientArg], InternalArgs, [...ServerArgs, arg: _ServerArg], Returns, ClientReturns, ServerReturns, Nullable>;
+    msg<ArgName extends string, ExplicitType = unknown, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, Optional extends boolean = false, _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType, _ClientArg = PurifiedModel<_ArgType>, _ServerArg = DocumentModel<_ArgType>>(name: string, arg: Arg, option?: EndpointArgProps<Optional>): EndpointInfo<ReqType, Srvs, [...ArgNames, ArgName], Optional extends true ? [...Args, arg?: _ClientArg | null] : [...Args, arg: _ClientArg], InternalArgs, [...ServerArgs, arg: _ServerArg | (Optional extends true ? undefined : never)], Returns, ClientReturns, ServerReturns, Nullable>;
+    search<ArgName extends string, ExplicitType = unknown, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType, _ClientArg = PurifiedModel<_ArgType>, _ServerArg = DocumentModel<_ArgType>>(name: string, arg: Arg, option?: Omit<EndpointArgProps, "nullable">): EndpointInfo<ReqType, Srvs, [...ArgNames, ArgName], [...Args, arg?: _ClientArg | null], InternalArgs, [...ServerArgs, arg: _ServerArg | undefined], Returns, ClientReturns, ServerReturns, Nullable>;
+    _addArgs(args: ArgInfo<EndpointArgProps<boolean>>[]): this;
+    with<ArgType, Optional extends boolean = false>(argRef: InternalArgCls<ArgType>, option?: InternalArgProps<Optional>): EndpointInfo<ReqType, Srvs, ArgNames, Args, [...InternalArgs, arg: NonNullable<ArgType> | (Optional extends true ? null : never)], ServerArgs, Returns, ClientReturns, ServerReturns, Nullable>;
+    _addInternalArgs(args: InternalArgInfo<boolean>[]): this;
+    exec<ExecFn extends (this: Srvs, ...args: [...ServerArgs, ...InternalArgs]) => ReqType extends "pubsub" ? Promise<void> | void : PromiseOrObject<DocumentModel<FieldToValue<Returns>> | (Nullable extends true ? null | undefined : never)>>(execFn: ExecFn): EndpointInfo<ReqType, Srvs, ArgNames, Args, InternalArgs, ServerArgs, Returns, FieldToValue<Returns>, ReturnType<ExecFn>, Nullable>;
+    getPath(key: string): string;
+}
+export type BuildEndpoint<SrvModule extends ServiceModel = ServiceModel> = {
+    query: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(returnRef: Returns, signalOption?: SignalOption<Returns, Nullable>) => EndpointInfo<"query", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+    mutation: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(returnRef: Returns, signalOption?: SignalOption<Returns, Nullable>) => EndpointInfo<"mutation", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+    pubsub: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(returnRef: Returns, signalOption?: SignalOption<Returns, Nullable>) => EndpointInfo<"pubsub", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+    message: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(returnRef: Returns, signalOption?: SignalOption<Returns, Nullable>) => EndpointInfo<"message", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+};
+export declare const buildEndpoint: BuildEndpoint<any>;
+export type EndpointBuilder<SrvModule extends ServiceModel = ServiceModel> = (builder: BuildEndpoint<SrvModule>) => {
+    [key: string]: EndpointInfo;
+};
+export type EndpInfoReqType<E> = E extends EndpointInfo<infer T, any, any, any, any, any, any, any, any, any> ? T : never;
+export type EndpInfoSrvs<E> = E extends EndpointInfo<any, infer S, any, any, any, any, any, any, any, any> ? S : never;
+export type EndpInfoArgNames<E> = E extends EndpointInfo<any, any, infer N, any, any, any, any, any, any, any> ? N : never;
+export type EndpInfoArgs<E> = E extends EndpointInfo<any, any, any, infer A, any, any, any, any, any, any> ? A : never;
+export type EndpInfoInternalArgs<E> = E extends EndpointInfo<any, any, any, any, infer I, any, any, any, any, any> ? I : never;
+export type EndpInfoServerArgs<E> = E extends EndpointInfo<any, any, any, any, any, infer S, any, any, any, any> ? S : never;
+export type EndpInfoReturnRef<E> = E extends EndpointInfo<any, any, any, any, any, any, infer R, any, any, any> ? R : never;
+export type EndpInfoClientReturns<E> = E extends EndpointInfo<any, any, any, any, any, any, any, infer R, any, any> ? R : never;
+export type EndpInfoServerReturns<E> = E extends EndpointInfo<any, any, any, any, any, any, any, any, infer R, any> ? R : never;
+export type EndpInfoNullable<E> = E extends EndpointInfo<any, any, any, any, any, any, any, any, any, infer N> ? N : never;