@akanjs/signal 0.0.4

package/README.md

@@ -0,0 +1,11 @@
+# akan
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build akan` to build the library.
+
+## Running unit tests
+
+Run `nx test akan` to execute the unit tests via [Jest](https://jestjs.io).

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./src";

package/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var signal_exports = {};
+module.exports = __toCommonJS(signal_exports);
+__reExport(signal_exports, require("./src"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./src")
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@akanjs/signal",
+  "version": "0.0.4",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/akan-team/akanjs.git",
+    "directory": "pkgs/@akanjs/signal"
+  },
+  "dependencies": {
+    "@urql/core": "5.1.0",
+    "bull": "4.16.5",
+    "dayjs": "1.11.13",
+    "express": "4.21.2",
+    "immer": "10.1.1",
+    "mongoose": "8.9.3",
+    "next": "15.1.3",
+    "pluralize": "8.0.0",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "reflect-metadata": "0.2.2",
+    "socket.io": "4.8.1",
+    "socket.io-client": "4.8.1",
+    "tunnel-ssh": "5.2.0"
+  },
+  "main": "./index.js"
+}

package/src/client.d.ts

@@ -0,0 +1,51 @@
+import { type Client as GqlClient } from "@urql/core";
+import { type Socket } from "socket.io-client";
+interface SubscribeOption {
+    key: string;
+    roomId: string;
+    message: {
+        [key: string]: any;
+    };
+}
+declare class SocketIo {
+    socket: Socket;
+    roomSubscribeMap: Map<string, SubscribeOption>;
+    constructor(uri: string);
+    on(event: string, callback: (data: any) => void): void;
+    removeListener(event: string, callback?: (data: any) => void): void;
+    removeAllListeners(): void;
+    hasListeners(event: string): boolean;
+    emit(key: string, data: any): void;
+    subscribe(option: {
+        key: string;
+        roomId: string;
+        message: {
+            [key: string]: any;
+        };
+        handleEvent: (data: any) => void;
+    }): void;
+    unsubscribe(roomId: string, handleEvent: (data: any) => void): void;
+    disconnect(): this;
+}
+declare class Client {
+    static globalIoMap: Map<string, SocketIo>;
+    static tokenStore: Map<Client, string>;
+    waitUntilWebSocketConnected(ws?: string): Promise<true | undefined>;
+    isInitialized: boolean;
+    uri: string;
+    ws: string;
+    gql: GqlClient;
+    jwt: string | undefined | null;
+    getJwt(): Promise<string | null>;
+    io: SocketIo | null;
+    init(data?: Partial<Client>): void;
+    setIo(ws?: string): void;
+    getIo(ws?: string): SocketIo;
+    setLink(uri?: string): void;
+    setJwt(jwt: string): void;
+    reset(): void;
+    clone(data?: Partial<Client>): Client;
+    terminate(): void;
+}
+export declare const client: Client;
+export type { Client, SocketIo };

package/src/client.js

@@ -0,0 +1,164 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  client: () => client
+});
+module.exports = __toCommonJS(client_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_core = require("@urql/core");
+var import_socket = require("socket.io-client");
+class SocketIo {
+  socket;
+  roomSubscribeMap = /* @__PURE__ */ new Map();
+  constructor(uri) {
+    this.socket = (0, import_socket.io)(uri, { transports: ["websocket"] });
+    this.socket.on("connect", () => {
+      this.roomSubscribeMap.forEach((option) => {
+        this.socket.emit(option.key, { ...option.message, __subscribe__: true });
+      });
+    });
+  }
+  on(event, callback) {
+    this.socket.on(event, callback);
+  }
+  removeListener(event, callback) {
+    this.socket.removeListener(event, callback);
+  }
+  removeAllListeners() {
+    this.socket.removeAllListeners();
+  }
+  hasListeners(event) {
+    return this.socket.hasListeners(event);
+  }
+  emit(key, data) {
+    this.socket.emit(key, data);
+  }
+  subscribe(option) {
+    if (!this.roomSubscribeMap.has(option.roomId)) {
+      this.roomSubscribeMap.set(option.roomId, option);
+      this.socket.emit(option.key, { ...option.message, __subscribe__: true });
+    }
+    this.socket.on(option.roomId, option.handleEvent);
+  }
+  unsubscribe(roomId, handleEvent) {
+    this.socket.removeListener(roomId, handleEvent);
+    const option = this.roomSubscribeMap.get(roomId);
+    if (this.hasListeners(roomId) || !option)
+      return;
+    this.roomSubscribeMap.delete(roomId);
+    this.socket.emit(option.key, { ...option.message, __subscribe__: false });
+  }
+  disconnect() {
+    this.socket.disconnect();
+    return this;
+  }
+}
+class Client {
+  static globalIoMap = /* @__PURE__ */ new Map();
+  static tokenStore = /* @__PURE__ */ new Map();
+  async waitUntilWebSocketConnected(ws = import_base.baseClientEnv.serverWsUri) {
+    if (import_base.baseClientEnv.side === "server")
+      return true;
+    while (!this.getIo(ws).socket.connected) {
+      import_common.Logger.verbose("waiting for websocket to initialize...");
+      await (0, import_common.sleep)(300);
+    }
+  }
+  isInitialized = false;
+  uri = import_base.baseClientEnv.serverGraphqlUri;
+  ws = import_base.baseClientEnv.serverWsUri;
+  gql = (0, import_core.createClient)({ url: this.uri, fetch, exchanges: [import_core.cacheExchange, import_core.fetchExchange] });
+  jwt = null;
+  async getJwt() {
+    const isNextServer = import_base.baseClientEnv.side === "server" && import_base.baseEnv.operationType === "client";
+    if (isNextServer) {
+      const nextHeaders = require("next/headers");
+      return (await nextHeaders.cookies?.())?.get("jwt")?.value ?? (await nextHeaders.headers?.())?.get("jwt") ?? this.jwt ?? null;
+    } else
+      return Client.tokenStore.get(this) ?? null;
+  }
+  io = null;
+  init(data = {}) {
+    Object.assign(this, data);
+    this.setLink(data.uri);
+    this.setIo(data.ws);
+    this.isInitialized = true;
+  }
+  setIo(ws = import_base.baseClientEnv.serverWsUri) {
+    this.ws = ws;
+    const existingIo = Client.globalIoMap.get(ws);
+    if (existingIo) {
+      this.io = existingIo;
+      return;
+    }
+    this.io = new SocketIo(ws);
+    Client.globalIoMap.set(ws, this.io);
+  }
+  getIo(ws = import_base.baseClientEnv.serverWsUri) {
+    const existingIo = Client.globalIoMap.get(ws);
+    if (existingIo)
+      return existingIo;
+    const io2 = new SocketIo(ws);
+    Client.globalIoMap.set(ws, io2);
+    return io2;
+  }
+  setLink(uri = import_base.baseClientEnv.serverGraphqlUri) {
+    this.uri = uri;
+    this.gql = (0, import_core.createClient)({
+      url: this.uri,
+      fetch,
+      exchanges: [import_core.cacheExchange, import_core.fetchExchange],
+      // requestPolicy: "network-only",
+      fetchOptions: () => {
+        return {
+          headers: {
+            "apollo-require-preflight": "true",
+            ...this.jwt ? { authorization: `Bearer ${this.jwt}` } : {}
+          }
+        };
+      }
+    });
+  }
+  setJwt(jwt) {
+    Client.tokenStore.set(this, jwt);
+  }
+  reset() {
+    this.io?.disconnect();
+    this.io = null;
+    this.jwt = null;
+  }
+  clone(data = {}) {
+    const newClient = new Client();
+    newClient.init({ ...this, ...data });
+    if (data.jwt)
+      Client.tokenStore.set(newClient, data.jwt);
+    return newClient;
+  }
+  terminate() {
+    this.reset();
+    Client.globalIoMap.forEach((io2) => io2.disconnect());
+    this.isInitialized = false;
+  }
+}
+const client = new Client();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  client
+});

package/src/doc.d.ts

@@ -0,0 +1,9 @@
+import { type Type } from "@akanjs/base";
+import { ArgMeta, SignalType } from "./signalDecorators";
+export declare const makeRequestExample: (sigRef: Type, key: string) => {
+    [key: string]: any;
+};
+export declare const getExampleData: (argMetas: ArgMeta[], signalType?: SignalType) => {
+    [key: string]: any;
+};
+export declare const makeResponseExample: (sigRef: Type, key: string) => string | number | boolean | object | null;

package/src/doc.js

@@ -0,0 +1,107 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var doc_exports = {};
+__export(doc_exports, {
+  getExampleData: () => getExampleData,
+  makeRequestExample: () => makeRequestExample,
+  makeResponseExample: () => makeResponseExample
+});
+module.exports = __toCommonJS(doc_exports);
+var import_base = require("@akanjs/base");
+var import_constant = require("@akanjs/constant");
+var import_signalDecorators = require("./signalDecorators");
+class ResponseExampleStorage {
+}
+const getPredefinedRequestExample = (modelRef) => {
+  return Reflect.getMetadata(modelRef, ResponseExampleStorage.prototype);
+};
+const getPredefinedResponseExample = (modelRef) => {
+  return Reflect.getMetadata(modelRef, ResponseExampleStorage.prototype);
+};
+const getResponseExample = (ref) => {
+  const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(ref);
+  const existing = getPredefinedRequestExample(modelRef);
+  if (existing)
+    return existing;
+  const isScalar = (0, import_base.isGqlScalar)(modelRef);
+  if (isScalar)
+    return (0, import_base.arraiedModel)((0, import_constant.getScalarExample)(modelRef), arrDepth);
+  const fieldMetas = (0, import_constant.getFieldMetas)(modelRef);
+  const example = {};
+  fieldMetas.forEach((fieldMeta) => {
+    if (fieldMeta.example)
+      example[fieldMeta.key] = fieldMeta.example;
+    else if (fieldMeta.enum)
+      example[fieldMeta.key] = (0, import_base.arraiedModel)(fieldMeta.enum.values[0], fieldMeta.arrDepth);
+    else
+      example[fieldMeta.key] = getResponseExample(fieldMeta.modelRef);
+  });
+  const result = (0, import_base.arraiedModel)(example, arrDepth);
+  Reflect.defineMetadata(ref, result, ResponseExampleStorage.prototype);
+  return result;
+};
+class RequestExampleStorage {
+}
+const getRequestExample = (ref) => {
+  const existing = getPredefinedRequestExample(ref);
+  if (existing)
+    return existing;
+  const fieldMetas = (0, import_constant.getFieldMetas)(ref);
+  const example = {};
+  const isScalar = (0, import_base.isGqlScalar)(ref);
+  if (isScalar)
+    return (0, import_constant.getScalarExample)(ref);
+  else {
+    fieldMetas.forEach((fieldMeta) => {
+      if (!fieldMeta.isScalar && fieldMeta.isClass)
+        example[fieldMeta.key] = "ObjectID";
+      else
+        example[fieldMeta.key] = fieldMeta.example ?? fieldMeta.enum ? (0, import_base.arraiedModel)(fieldMeta.example ?? (fieldMeta.enum?.values)[0], fieldMeta.optArrDepth) : (0, import_base.arraiedModel)(getRequestExample(fieldMeta.modelRef), fieldMeta.arrDepth);
+    });
+  }
+  Reflect.defineMetadata(ref, example, RequestExampleStorage.prototype);
+  return example;
+};
+const makeRequestExample = (sigRef, key) => {
+  const [argMetas] = (0, import_signalDecorators.getArgMetas)(sigRef, key);
+  return getExampleData(argMetas);
+};
+const getExampleData = (argMetas, signalType = "graphql") => Object.fromEntries(
+  argMetas.filter((argMeta) => argMeta.type !== "Upload").map((argMeta) => {
+    const [argRef, argArrDepth] = (0, import_base.getNonArrayModel)(argMeta.returns());
+    const example = argMeta.argsOption.example ?? getRequestExample(argRef);
+    return [
+      argMeta.name,
+      (0, import_base.arraiedModel)(
+        signalType === "restapi" && argRef.prototype === import_base.JSON.prototype ? JSON.stringify(example, null, 2) : example,
+        argArrDepth
+      )
+    ];
+  })
+);
+const makeResponseExample = (sigRef, key) => {
+  const gqlMeta = (0, import_signalDecorators.getGqlMeta)(sigRef, key);
+  const example = getResponseExample(gqlMeta.returns());
+  return example;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getExampleData,
+  makeRequestExample,
+  makeResponseExample
+});

package/src/gql.d.ts

@@ -0,0 +1,226 @@
+import { DataList, Dayjs, Type, Upload } from "@akanjs/base";
+import { FetchPolicy } from "@akanjs/common";
+import { ConstantModel, DocumentModel, FilterType, ProtoFile, QueryOf, SortOf } from "@akanjs/constant";
+import { type Client } from ".";
+import { type ArgMeta, type DefaultSignal, type GqlMeta, type SliceMeta } from "./signalDecorators";
+export declare class GqlStorage {
+}
+export declare class FragmentStorage {
+}
+export declare class PurifyStorage {
+}
+export declare class DefaultStorage {
+}
+export declare class CrystalizeStorage {
+}
+export type PurifyFunc<I, M> = (self: DefaultOf<Pick<M, keyof I extends keyof M ? keyof I : never>>, isChild?: boolean) => DocumentModel<I> | null;
+export type CrystalizeFunc<M> = (self: {
+    [K in keyof M as M[K] extends (...args: any) => any ? never : K]: M[K];
+}, isChild?: boolean) => M;
+export type FieldState<T> = T extends string ? T : T extends number ? T : T extends boolean ? T : T extends Dayjs ? T : T extends any[] ? T : T extends {
+    id: string;
+} ? T | null : T;
+export type DefaultOf<S> = S extends infer T ? {
+    [K in keyof T]: FieldState<T[K]>;
+} : never;
+export interface FetchInitForm<Input, Full, Filter extends FilterType> {
+    page?: number;
+    limit?: number;
+    sort?: SortOf<Filter> | symbol;
+    default?: Partial<DefaultOf<Input>>;
+    invalidate?: boolean;
+    insight?: boolean;
+}
+export type ServerInit<T extends string, Light, Insight = any, QueryArgs = any[], Filter extends FilterType = any> = SliceMeta & {
+    [K in `${Uncapitalize<T>}ObjList`]: Light[];
+} & {
+    [K in `${Uncapitalize<T>}ObjInsight`]: Insight;
+} & {
+    [K in `pageOf${Capitalize<T>}`]: number;
+} & {
+    [K in `lastPageOf${Capitalize<T>}`]: number;
+} & {
+    [K in `limitOf${Capitalize<T>}`]: number;
+} & {
+    [K in `queryArgsOf${Capitalize<T>}`]: QueryArgs;
+} & {
+    [K in `sortOf${Capitalize<T>}`]: SortOf<Filter>;
+} & {
+    [K in `${Uncapitalize<T>}InitAt`]: Date;
+};
+export type ClientInit<T extends string, Light, Insight = any, QueryArgs = any[], Filter extends FilterType = any> = Promise<ServerInit<T, Light, Insight, QueryArgs, Filter>> | ServerInit<T, Light, Insight, QueryArgs, Filter>;
+export type ServerView<T extends string, M> = {
+    refName: T;
+} & {
+    [K in `${Uncapitalize<T>}Obj`]: M;
+} & {
+    [K in `${Uncapitalize<T>}ViewAt`]: Date;
+};
+export type ClientView<T extends string, M> = Promise<ServerView<T, M>> | ServerView<T, M>;
+export type ServerEdit<T extends string, M> = {
+    refName: T;
+} & {
+    [K in `${Uncapitalize<T>}Obj`]: M;
+} & {
+    [K in `${Uncapitalize<T>}ViewAt`]: Date;
+};
+export type ClientEdit<T extends string, M> = Promise<ServerEdit<T, M>> | ServerEdit<T, M>;
+export type GqlScalarUtil<T extends string, M, I = M> = {
+    [K in `default${Capitalize<T>}`]: DefaultOf<M>;
+} & {
+    [K in `purify${Capitalize<T>}`]: PurifyFunc<DocumentModel<I>, M>;
+} & {
+    [K in `crystalize${Capitalize<T>}`]: CrystalizeFunc<M>;
+};
+type FilterSkipLimitSort<Args, Filter> = Args extends [
+    ...args: infer QueryArgs,
+    skip: number | null,
+    limit: number | null,
+    sort: string | null
+] ? QueryArgs : never;
+export type FilterListArgs<Args, Filter> = FilterOutInternalArgs<FilterSkipLimitSort<FilterOutInternalArgs<Args>, Filter>>;
+export type FilterStateArgs<Args, Filter> = FilterSkipLimitSort<FilterOutInternalArgs<Args>, Filter>;
+export type DbGraphQL<T extends string, Input, Full, Light extends {
+    id: string;
+}, Insight, Filter extends FilterType, Fetch, Signal> = {
+    refName: string;
+    slices: SliceMeta[];
+} & GetWsMessageOf<Signal> & GetWsPubsubOf<Signal> & GqlScalarUtil<T, Full> & {
+    [K in `lightCrystalize${Capitalize<T>}`]: CrystalizeFunc<Light>;
+} & {
+    [K in `default${Capitalize<T>}Insight`]: Insight;
+} & {
+    [K in `add${Capitalize<T>}Files`]: (fileList: FileList, parentId?: string, option?: FetchPolicy) => Promise<ProtoFile[]>;
+} & {
+    [K in `merge${Capitalize<T>}`]: (modelOrId: Full | string, data: Partial<DocumentModel<Input>>, option?: FetchPolicy) => Promise<Full>;
+} & {
+    [K in `view${Capitalize<T>}`]: (id: string, option?: FetchPolicy) => Promise<{
+        [K in Uncapitalize<T>]: Full;
+    } & {
+        [K in `${Uncapitalize<T>}View`]: ServerView<T, Full>;
+    }>;
+} & {
+    [K in `get${Capitalize<T>}View`]: (id: string, option?: FetchPolicy) => ClientView<T, Full>;
+} & {
+    [K in `edit${Capitalize<T>}`]: (id: string, option?: FetchPolicy) => Promise<{
+        [K in Uncapitalize<T>]: Full;
+    } & {
+        [K in `${Uncapitalize<T>}Edit`]: ServerEdit<T, Full>;
+    }>;
+} & {
+    [K in `get${Capitalize<T>}Edit`]: (id: string, option?: FetchPolicy) => ClientEdit<T, Full>;
+} & Fetch & {
+    [K in `init${Capitalize<T>}`]: (query?: QueryOf<DocumentModel<Full>>, option?: FetchPolicy & FetchInitForm<Input, Full, Filter>) => Promise<{
+        [K in `${Uncapitalize<T>}Init`]: ServerInit<T, Light, Insight, [query?: QueryOf<DocumentModel<Full>>], Filter>;
+    } & {
+        [K in `${Uncapitalize<T>}List`]: DataList<Light>;
+    } & {
+        [K in `${Uncapitalize<T>}Insight`]: Insight;
+    }>;
+} & {
+    [K in `get${Capitalize<T>}Init`]: (query?: QueryOf<DocumentModel<Full>>, option?: FetchPolicy & FetchInitForm<Input, Full, Filter>) => ClientInit<T, Light, Insight, [query?: QueryOf<DocumentModel<Full>>], Filter>;
+} & {
+    [K in keyof Signal as K extends `${T}List${infer Suffix}` ? `init${Capitalize<T>}${Suffix}` : never]: K extends `${T}List${infer Suffix}` ? Signal[K] extends (...args: infer Args) => Promise<Full[]> ? (...args: [
+        ...queryArgs: FilterListArgs<Args, Filter>,
+        option?: FetchPolicy & FetchInitForm<Input, Full, Filter>
+    ]) => Promise<{
+        [K in `${Uncapitalize<T>}Init${Suffix}`]: ServerInit<T, Light, Insight, FilterListArgs<Args, Filter>, Filter>;
+    } & {
+        [K in `${Uncapitalize<T>}List${Suffix}`]: DataList<Light>;
+    } & {
+        [K in `${Uncapitalize<T>}Insight${Suffix}`]: Insight;
+    }> : never : never;
+} & {
+    [K in keyof Signal as K extends `${T}List${infer Suffix}` ? `get${Capitalize<T>}Init${Suffix}` : never]: K extends `${T}List${infer Suffix}` ? Signal[K] extends (...args: infer Args) => Promise<Full[]> ? (...args: [
+        ...queryArgs: FilterListArgs<Args, Filter>,
+        option?: FetchPolicy & FetchInitForm<Input, Full, Filter>
+    ]) => ClientInit<T, Light, Insight, FilterListArgs<Args, Filter>, Filter> : never : never;
+};
+type ConvertArg<T> = T extends Upload[] ? FileList : T;
+type IsInternalArgs<T> = T extends {
+    __InternalArg__: any;
+} ? true : T extends {
+    __InternalArg__: any;
+} | null ? true : false;
+export type FilterOutInternalArgs<T> = T extends [arg: infer Head, ...args: infer Rest] ? IsInternalArgs<Head> extends true ? FilterOutInternalArgs<Rest> : Head extends undefined ? [arg?: ConvertArg<Head> | undefined, ...args: FilterOutInternalArgs<Rest>] : Head extends null ? [arg?: ConvertArg<Head> | undefined, ...args: FilterOutInternalArgs<Rest>] : [
+    arg: ConvertArg<Head>,
+    ...args: FilterOutInternalArgs<Rest>
+] : [];
+type FunctionToTuple<F extends (...args: any) => any> = F extends (...args: infer A) => any ? A : never;
+type TupleToFunction<T extends any[], R> = (...args: [...args: T, option?: FetchPolicy]) => R;
+export type RemoveInternalArgs<F extends (...args: any) => any, Returns = ReturnType<F>> = TupleToFunction<FilterOutInternalArgs<FunctionToTuple<F>>, Returns>;
+type ApplyPromise<T> = T extends (...args: infer Args) => infer Return ? Return extends Promise<any> ? T : (...args: Args) => Promise<Return> : never;
+type ApplyVoidReturn<T> = T extends (...args: infer Args) => any ? (...args: Args) => void : never;
+export type GetQueryMutationOf<Sig, M = unknown> = {
+    [K in keyof Sig as K extends keyof M ? never : Sig[K] extends (...args: any) => Promise<{
+        __Returns__: string;
+    }> ? never : K]: Sig[K] extends (...args: any) => any ? ApplyPromise<RemoveInternalArgs<Sig[K]>> : never;
+};
+export type GetWsMessageOf<Sig> = {
+    [K in keyof Sig as Sig[K] extends (...args: any) => Promise<{
+        __Returns__: "Emit";
+    }> ? K : Sig[K] extends (...args: any) => {
+        __Returns__: "Emit";
+    } ? K : never]: Sig[K] extends (...args: any) => any ? ApplyVoidReturn<RemoveInternalArgs<Sig[K], void>> : never;
+} & {
+    [K in keyof Sig as K extends string ? Sig[K] extends (...args: any) => Promise<{
+        __Returns__: "Emit";
+    }> | {
+        __Returns__: "Emit";
+    } ? `listen${Capitalize<K>}` : never : never]: Sig[K] extends (...args: any) => any ? (handleEvent: (data: Awaited<ReturnType<Sig[K]>>) => any, options?: FetchPolicy) => () => void : never;
+};
+export type GetWsPubsubOf<Sig> = {
+    [K in keyof Sig as K extends string ? Sig[K] extends (...args: any) => Promise<{
+        __Returns__: "Subscribe";
+    }> ? `subscribe${Capitalize<K>}` : Sig[K] extends (...args: any) => {
+        __Returns__: "Subscribe";
+    } ? `subscribe${Capitalize<K>}` : never : never]: Sig[K] extends (...args: infer Args) => Promise<{
+        __Returns__: "Subscribe";
+    } & infer Return> ? (...args: [...args: FilterOutInternalArgs<Args>, onData: (data: Return) => void, fetchPolicy?: FetchPolicy]) => () => void : Sig[K] extends (...args: infer Args) => {
+        __Returns__: "Subscribe";
+    } & infer Return ? (...args: [...args: FilterOutInternalArgs<Args>, onData: (data: Return) => void, fetchPolicy?: FetchPolicy]) => () => void : never;
+};
+export declare const scalarUtilOf: <T extends string, M>(name: T, target: Type<M>) => GqlScalarUtil<T, M>;
+type LightWeightFetch<Fetch, Full, Light> = {
+    [K in keyof Fetch]: Fetch[K] extends (...args: infer Args) => Promise<Full[]> ? (...args: Args) => Promise<Light[]> : Fetch[K];
+};
+export declare const getGqlOnStorage: (refName: string) => {
+    [key: string]: any;
+};
+export declare const gqlOf: <T extends string, Input, Full extends {
+    id: string;
+}, Light extends {
+    id: string;
+}, Insight, Summary, Filter extends FilterType, Signal>(constant: ConstantModel<T, Input, Full, Light, Insight, Filter, Summary>, sigRef: Type<Signal>, option?: {
+    overwrite?: {
+        [key: string]: any;
+    };
+}) => DbGraphQL<T, Input, Full, Light, Insight, Filter, LightWeightFetch<GetQueryMutationOf<Signal & DefaultSignal<T, Input, Full, Light, Insight, Filter>, Full>, Full, Light>, Signal>;
+export declare const makeDefault: <T>(target: Type<T>, option?: {
+    isChild?: boolean;
+    overwrite?: any;
+}) => DefaultOf<T>;
+export declare const makePurify: <I, M = I>(target: Type<I>, option?: {
+    overwrite?: any;
+}) => PurifyFunc<I, M>;
+export declare const makeCrystalize: <M>(target: Type<M>, option?: {
+    overwrite?: any;
+    partial?: string[];
+}) => CrystalizeFunc<M>;
+export declare const makeFragment: (target: Type, option?: {
+    overwrite?: any;
+    excludeSelf?: boolean;
+    partial?: string[];
+}) => string;
+export declare const getGqlStr: (modelRef: Type, gqlMeta: GqlMeta, argMetas: ArgMeta[], returnRef: Type, partial?: string[]) => string;
+export declare const serializeArg: (argMeta: ArgMeta, value: any) => object[] | null;
+export declare const deserializeArg: (argMeta: ArgMeta, value: any) => object[] | null;
+export declare const fetchOf: <Signal>(sigRef: Type<Signal>) => GetWsMessageOf<Signal> & GetWsPubsubOf<Signal> & GetQueryMutationOf<Signal>;
+type CustomFetch<T> = Omit<T, "client" | "clone"> & {
+    client: Client;
+    clone: (option?: {
+        jwt: string | null;
+    }) => CustomFetch<T>;
+};
+export declare const makeFetch: <F1 extends object, F2 extends object, F3 extends object, F4 extends object, F5 extends object, F6 extends object, F7 extends object, F8 extends object, F9 extends object, F10 extends object>(fetch1: F1, fetch2?: Partial<F2>, fetch3?: Partial<F3>, fetch4?: Partial<F4>, fetch5?: Partial<F5>, fetch6?: Partial<F6>, fetch7?: Partial<F7>, fetch8?: Partial<F8>, fetch9?: Partial<F9>, fetch10?: Partial<F10>) => CustomFetch<F10 & F9 & F8 & F7 & F6 & F5 & F4 & F3 & F2 & F1>;
+export {};