@akanjs/signal 0.0.39 → 0.0.41

package/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/signal",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"

package/src/baseFetch.d.ts

@@ -0,0 +1,6 @@
+export declare const baseFetch: typeof fetch & {
+    client: import("./client").Client;
+    clone: (option?: {
+        jwt?: string | null;
+    }) => any;
+};

package/src/client.d.ts

@@ -0,0 +1,54 @@
+import { type Client as GqlClient } from "@urql/core";
+import type * as dgram from "dgram";
+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;
+    udp: dgram.Socket | null;
+    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;
+    setUdp(udp: dgram.Socket): void;
+}
+export declare const client: Client;
+export type { Client, SocketIo };

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/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 {};

package/src/immerify.d.ts

@@ -0,0 +1,2 @@
+import { type Type } from "@akanjs/base";
+export declare const immerify: <T extends object | object[]>(modelRef: Type, objOrArr: T) => T;

package/src/index.d.ts

@@ -0,0 +1,6 @@
+export { type Client, client } from "./client";
+export { immerify } from "./immerify";
+export * from "./gql";
+export * from "./signalDecorators";
+export * from "./doc";
+export * from "./baseFetch";

package/src/signalDecorators.d.ts

@@ -0,0 +1,295 @@
+import "reflect-metadata";
+import { BaseObject, Dayjs, Enum, Environment, SingleFieldType, Type } from "@akanjs/base";
+import { ConstantModel, DocumentModel, FilterType, GetActionObject, ReturnType, SortOf } from "@akanjs/constant";
+import type { Job as BullJob } from "bull";
+import type { Request as ExpressRequest, Response as ExpressResponse } from "express";
+import type { Socket } from "socket.io";
+export declare const ssoTypes: readonly ["github", "google", "facebook", "apple", "naver", "kakao"];
+export type SSOType = (typeof ssoTypes)[number];
+export declare class SignalStorage {
+}
+export declare const getAllSignalRefs: () => Type[];
+export declare const getSignalRefsOnStorage: (refName: string) => Type[];
+export type Resolve<T> = T;
+export declare const resolve: <T>(data: any) => Resolve<T>;
+export declare const emit: <T>(data: any) => Resolve<T> & {
+    __Returns__: "Emit";
+};
+export declare const done: <T>(data: any) => Resolve<T> & {
+    __Returns__: "Done";
+};
+export declare const subscribe: <T>() => Resolve<T> & {
+    __Returns__: "Subscribe";
+};
+export interface SignalOption<Response = any> {
+    nullable?: boolean;
+    name?: string;
+    default?: boolean;
+    path?: string;
+    onlyFor?: "graphql" | "restapi";
+    sso?: SSOType;
+    serverType?: "federation" | "batch" | "all";
+    timeout?: number;
+    partial?: (keyof Response)[] | readonly (keyof Response)[];
+    cache?: number;
+}
+export interface ResolveFieldMeta {
+    returns: ReturnType;
+    argsOption: ArgsOption;
+    key: string;
+    descriptor: PropertyDescriptor;
+}
+export declare const signalTypes: readonly ["graphql", "restapi"];
+export type SignalType = (typeof signalTypes)[number];
+export declare const endpointTypes: readonly ["Query", "Mutation", "Message", "Pubsub", "Process"];
+export type EndpointType = (typeof endpointTypes)[number];
+export declare const guardTypes: readonly ["Public", "None", "User", "Admin", "SuperAdmin", "Every", "Owner"];
+export type GuardType = (typeof guardTypes)[number];
+export declare const roleTypes: readonly ["Public", "User", "Admin", "SuperAdmin"];
+export type RoleType = (typeof roleTypes)[number];
+export declare const argTypes: readonly ["Body", "Param", "Query", "Upload", "Msg", "Room"];
+export type ArgType = (typeof argTypes)[number];
+export declare const internalArgTypes: readonly ["Account", "Me", "Self", "UserIp", "Access", "Parent", "Req", "Res", "Ws", "Job"];
+export type InternalArgType = (typeof internalArgTypes)[number];
+export interface GqlMeta {
+    returns: (of?: any) => Type;
+    signalOption: SignalOption;
+    key: string;
+    descriptor: PropertyDescriptor;
+    guards: GuardType[];
+    type: EndpointType;
+}
+export interface ArgsOption {
+    nullable?: boolean;
+    example?: string | number | boolean | Dayjs;
+    enum?: Enum<string | number>;
+}
+export interface ArgMeta {
+    name: string;
+    returns: ReturnType;
+    argsOption: ArgsOption;
+    key: string;
+    idx: number;
+    type: ArgType;
+}
+export interface InternalArgMeta {
+    key: string;
+    idx: number;
+    type: InternalArgType;
+    option?: {
+        nullable?: boolean;
+    };
+}
+export interface SliceMeta {
+    refName: string;
+    sliceName: string;
+    argLength: number;
+    defaultArgs: any[];
+}
+export interface SignalMeta {
+    refName: string;
+    slices: SliceMeta[];
+    returns?: (of?: any) => Type;
+    prefix?: string;
+}
+interface SignalDecoratorInput {
+    name: string;
+    prefix?: string;
+}
+export declare function Signal(returnsOrObj: (() => Type) | SignalDecoratorInput): (target: Type) => void;
+export declare const createArgMetaDecorator: (type: InternalArgType) => (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export declare const Account: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export type Account<AddData = unknown> = {
+    __InternalArg__: "Account";
+    self?: Self;
+    me?: Me;
+    appName: string;
+    environment: Environment;
+} & AddData;
+export declare const defaultAccount: Account;
+export declare const Self: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export interface Self {
+    __InternalArg__: "Self";
+    id: string;
+    nickname: string;
+    roles: string[];
+    image: {
+        url: string;
+        imageSize: [number, number];
+    } | null;
+    profileStatus: "active" | "prepare" | "applied" | "approved" | "reapplied" | "featured" | "reserved" | "rejected";
+    status: "prepare" | "active" | "restricted" | "dormant";
+    removedAt: Dayjs | null;
+}
+export declare const Me: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export interface Me {
+    __InternalArg__: "Me";
+    id: string;
+    accountId: string;
+    roles: string[];
+    status: "active";
+    removedAt: Dayjs | null;
+}
+export declare const UserIp: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export interface UserIp {
+    ip: string;
+    __InternalArg__: "UserIp";
+}
+export declare const Access: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export interface Access {
+    __InternalArg__: "Access";
+    period: number;
+    countryCode?: string;
+    countryName?: string;
+    city?: string;
+    postal?: number;
+    location?: {
+        type: "Point";
+        coordinates: [number, number];
+    };
+    ipv4?: string;
+    state?: string;
+    userAgent?: string;
+    at: Dayjs;
+}
+export declare const Req: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export type Req = {
+    __InternalArg__: "Req";
+    account: Account;
+    user: any;
+} & ExpressRequest;
+export declare const Res: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export type Res = {
+    __InternalArg__: "Res";
+} & ExpressResponse;
+export declare const Ws: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export type Ws = {
+    __InternalArg__: "Ws";
+} & {
+    socket: Socket;
+    subscribe: boolean;
+    onSubscribe: (handler: () => void | Promise<void>) => void;
+    onUnsubscribe: (handler: () => void | Promise<void>) => void;
+    onDisconnect: (handler: () => void | Promise<void>) => void;
+};
+export declare const Job: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export type Job = {
+    __InternalArg__: "Job";
+} & BullJob;
+type Guard = <Response extends SingleFieldType>(returns: ReturnType<Response>, signalOption?: SignalOption<UnType<Response>>, guards?: GuardType[]) => MethodDecorator;
+export declare const Query: {
+    Public: Guard;
+    Every: Guard;
+    Admin: Guard;
+    User: Guard;
+    SuperAdmin: Guard;
+    None: Guard;
+    Owner: Guard;
+};
+export declare const Mutation: {
+    Public: Guard;
+    Every: Guard;
+    Admin: Guard;
+    User: Guard;
+    SuperAdmin: Guard;
+    None: Guard;
+    Owner: Guard;
+};
+export declare const Message: {
+    Public: Guard;
+    Every: Guard;
+    Admin: Guard;
+    User: Guard;
+    SuperAdmin: Guard;
+    None: Guard;
+    Owner: Guard;
+};
+export declare const Pubsub: {
+    Public: Guard;
+    Every: Guard;
+    Admin: Guard;
+    User: Guard;
+    SuperAdmin: Guard;
+    None: Guard;
+    Owner: Guard;
+};
+export declare const Process: {
+    Federation: Guard;
+    Batch: Guard;
+    All: Guard;
+};
+export declare function ResolveField(returns: ReturnType, argsOption?: ArgsOption): (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare const Arg: {
+    Body: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Param: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Query: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Upload: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Msg: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Room: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+};
+export declare function Parent(): (prototype: object, key: string, idx: number) => void;
+export declare function LogSignal<Srv>(srv: Srv): Type<{ [K in keyof Srv as K extends string ? Uncapitalize<K> : never]: Srv[K]; }>;
+type UnType<Class> = Class extends Type<infer T> ? T : never;
+export type DefaultSignal<T extends string, Input, Full, Light, Insight, Filter extends FilterType> = DefaultSignalWithQuerySort<T, Input, Full, Light, Insight, GetActionObject<Filter>, SortOf<Filter>>;
+type DefaultSignalWithQuerySort<T extends string, Input, Full, Light, Insight, Query, Sort> = {
+    [K in Uncapitalize<T>]: (id: string) => Promise<Full>;
+} & {
+    [K in `light${Capitalize<T>}`]: (id: string) => Promise<Light>;
+} & {
+    [K in `${Uncapitalize<T>}List`]: (...args: [query: Query, skip: number | null, limit: number | null, sort: Sort | null]) => Promise<Full[]>;
+} & {
+    [K in `${Uncapitalize<T>}Insight`]: (query: Query) => Promise<Insight>;
+} & {
+    [K in `${Uncapitalize<T>}Exists`]: (query: Query) => Promise<boolean>;
+} & {
+    [K in `create${Capitalize<T>}`]: (data: DocumentModel<Input>, account: Account) => Promise<Full>;
+} & {
+    [K in `update${Capitalize<T>}`]: (id: string, data: DocumentModel<Input>, account: Account) => Promise<Full>;
+} & {
+    [K in `remove${Capitalize<T>}`]: (id: string, account: Account) => Promise<Full>;
+};
+export declare function DbSignal<Srv>(constant: ConstantModel<string, any, BaseObject & {
+    status: string;
+}, BaseObject, {
+    count: number;
+}, any>, srv: Srv, option: {
+    guards: {
+        get: Guard;
+        cru: Guard;
+    };
+    omit?: ("get" | "list" | "insight" | "exist" | "create" | "update" | "remove")[];
+}): Type<{ [K in keyof Srv as K extends string ? Uncapitalize<K> : never]: Srv[K]; }>;
+export declare const getSigMeta: (sigRef: Type) => SignalMeta;
+export declare const getGqlMeta: (sigRef: Type, key: string) => GqlMeta;
+export declare const getGqlMetaMapOnPrototype: (prototype: object) => Map<string, GqlMeta>;
+export declare const getGqlMetas: (sigRef: Type) => GqlMeta[];
+export declare const setGqlMetaMapOnPrototype: (prototype: object, gqlMetaMap: Map<string, GqlMeta>) => void;
+export declare const getArgMetas: (sigRef: Type, key: string) => [ArgMeta[], InternalArgMeta[]];
+export declare const setArgMetas: (sigRef: Type, key: string, argMetas: ArgMeta[], internalArgMetas: InternalArgMeta[]) => void;
+export declare const getResolveFieldMetas: (sigRef: Type) => ResolveFieldMeta[];
+export declare const getControllerPrefix: (sigMeta: SignalMeta) => string | undefined;
+export declare const getControllerPath: (gqlMeta: GqlMeta, paramArgMetas: ArgMeta[]) => string;
+export declare const copySignal: (sigRef: Type) => {
+    new (): {};
+};
+export {};