socket-function 0.159.0 → 0.161.0

package/index.d.ts

@@ -280,114 +280,6 @@ declare module "socket-function/index" {
 
         }
 
-        declare module "socket-function/SocketFunction" {
-            /// <reference path="require/RequireController.d.ts" />
-            /// <reference types="node" />
-            /// <reference types="node" />
-            import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "./SocketFunctionTypes";
-            import { SocketServerConfig } from "./src/webSocketServer";
-            import { Args, MaybePromise } from "./src/types";
-            import "./SetProcessVariables";
-            type ExtractShape<ClassType, Shape> = {
-                [key in keyof ClassType]: (key extends keyof Shape ? ClassType[key] extends SocketExposedInterface[""] ? ClassType[key] : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never : "Function has implementation but is not exposed in the SocketFunction.register call");
-            };
-            export declare class SocketFunction {
-                static logMessages: boolean;
-                static trackMessageSizes: {
-                    upload: ((size: number) => void)[];
-                    download: ((size: number) => void)[];
-                    callTimes: ((obj: {
-                        start: number;
-                        end: number;
-                    }) => void)[];
-                };
-                static MAX_MESSAGE_SIZE: number;
-                static HTTP_ETAG_CACHE: boolean;
-                static silent: boolean;
-                static HTTP_COMPRESS: boolean;
-                static COEP: string;
-                static COOP: string;
-                static readonly WIRE_SERIALIZER: {
-                    serialize: (obj: unknown) => MaybePromise<Buffer[]>;
-                    deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
-                };
-                static WIRE_WARN_TIME: number;
-                private static onMountCallbacks;
-                static exposedClasses: Set<string>;
-                static callerContext: CallerContext | undefined;
-                static getCaller(): CallerContext;
-                static harvestFailedCallCount: () => number;
-                static getPendingCallCount: () => number;
-                static harvestCallTimes: () => {
-                    start: number;
-                    end: number;
-                }[];
-                static register<ClassInstance extends object, Shape extends SocketExposedShape<{
-                    [key in keyof ClassInstance]: (...args: any[]) => Promise<unknown>;
-                }>, Statics>(classGuid: string, instance: ClassInstance | (() => ClassInstance), shapeFnc: () => Shape, defaultHooksFnc?: () => SocketExposedShape[""] & {
-                    onMount?: () => MaybePromise<void>;
-                }, config?: {
-                    /** @noAutoExpose If true SocketFunction.expose(Controller) must be called explicitly. */
-                    noAutoExpose?: boolean;
-                    statics?: Statics;
-                    /** Skip timing functions calls. Useful if a lot of functions have wait time that
-                            is unrelated to processing, and therefore their timings won't be useful.
-                            - Also useful if our auto function wrapping code is breaking functionality,
-                                such as if you have a singleton function which you compare with ===,
-                                which will breaks because we replaced it with a wrapped measure function.
-                    */
-                    noFunctionMeasure?: boolean;
-                }): SocketRegistered<ExtractShape<ClassInstance, Shape>> & Statics;
-                private static socketCache;
-                static rehydrateSocketCaller<Controller>(socketRegistered: SocketRegisterType<Controller>, shapeFnc?: () => SocketExposedShape): SocketRegistered<Controller>;
-                private static callFromGuid;
-                static onNextDisconnect(nodeId: string, callback: () => void): void;
-                static getLastDisconnectTime(nodeId: string): number | undefined;
-                static isNodeConnected(nodeId: string): boolean;
-                /** NOTE: Only works if the nodeIs used is from SocketFunction.connect (we can't convert arbitrary nodeIds into urls,
-                 *      as we have no way of knowing how to contain a nodeId).
-                 *  */
-                static getHTTPCallLink(call: FullCallType): string;
-                private static ignoreExposeCount;
-                static ignoreExposeCalls<T>(code: () => Promise<T>): Promise<T>;
-                /** Expose should be called before your mounting occurs. It mostly just exists to ensure you include the class type,
-                 *      so the class type's module construction runs, which should trigger register. Otherwise you would have
-                 *      to add additional imports to ensure the register call runs.
-                 */
-                static expose(socketRegistered: SocketRegistered): void;
-                static mountedNodeId: string;
-                static isMounted(): boolean;
-                static mountedIP: string;
-                private static hasMounted;
-                private static onMountCallback;
-                static mountPromise: Promise<void>;
-                static mount(config: SocketServerConfig): Promise<string>;
-                /** Sets the default call when an http request is made, but no classGuid is set.
-                 *      NOTE: All other calls should be endpoint calls, even if those endpoints return a static file with an HTML content type.
-                 *          - However, to load new content, you should probably just use `require("./example.ts")`, which works on any files
-                 *              clientside that have also been required serverside (and whitelisted with module.allowclient = true,
-                 *              or with an `allowclient.flag` file in the directory or parent directory).
-                */
-                static setDefaultHTTPCall<Registered extends SocketRegistered, FunctionName extends keyof Registered["nodes"][""] & string>(registered: Registered, functionName: FunctionName, ...args: Args<Registered["nodes"][""][FunctionName]>): void;
-                static connect(location: {
-                    address: string;
-                    port: number;
-                }): string;
-                static browserNodeId(): string;
-                static getBrowserNodeId(): string;
-                static addGlobalHook(hook: SocketFunctionHook): void;
-                static addGlobalClientHook(hook: SocketFunctionClientHook): void;
-            }
-            declare global {
-                var BOOTED_EDGE_NODE: {
-                    host: string;
-                } | undefined;
-            }
-            export declare function _setSocketContext<T>(caller: CallerContext, code: () => T): T;
-            export {};
-
-        }
-
         declare module "socket-function/SocketFunctionTypes" {
             /// <reference path="require/RequireController.d.ts" />
             import { getCallObj } from "./src/nodeProxy";
@@ -514,297 +406,2521 @@ declare module "socket-function/index" {
                 fileUpdated: (files: string[], changeTime: number) => Promise<void>;
             }>;
 
-        }
+        }
+
+        declare module "socket-function/index" {
+            // Auto-generated file. Do not edit manually.
+            // Generated by: yarn generate-index-dts
+
+            declare module "socket-function/SetProcessVariables" {
+                export {};
+
+            }
+
+            declare module "socket-function/SocketFunctionTypes" {
+                /// <reference path="require/RequireController.d.ts" />
+                import { getCallObj } from "./src/nodeProxy";
+                import { Args, MaybePromise } from "./src/types";
+                export declare const socket: unique symbol;
+                export type SocketExposedInterface = {
+                    [functionName: string]: (...args: any[]) => Promise<unknown>;
+                };
+                export type SocketInternalInterface = {
+                    [functionName: string]: {
+                        [getCallObj]: (...args: any[]) => FullCallType;
+                        (...args: any[]): Promise<unknown>;
+                    };
+                };
+                export type SocketExposedInterfaceClass = {
+                    new (): unknown;
+                    prototype: unknown;
+                };
+                export type FunctionFlags = {
+                    compress?: boolean;
+                    /** Indicates with the same input, we give the same output, forever,
+                     *      independent of code changes. This only works for data storage.
+                     */
+                    dataImmutable?: boolean;
+                    /** Allows overriding SocketFunction.MAX_MESSAGE_SIZE for responses from this function. */
+                    responseLimit?: number;
+                };
+                export type SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
+                    [functionName in keyof ExposedType]?: FunctionFlags & {
+                        hooks?: SocketFunctionHook[];
+                        clientHooks?: SocketFunctionClientHook[];
+                        noDefaultHooks?: boolean;
+                        /** BUG: I think this is broken if it is on the default hooks function? */
+                        noClientHooks?: boolean;
+                    };
+                };
+                export type FncType = (...args: any[]) => Promise<unknown>;
+                export interface CallType<FncT extends FncType = FncType, FncName extends string = string> {
+                    classGuid: string;
+                    functionName: FncName;
+                    args: unknown[];
+                }
+                export interface FullCallType<FncT extends FncType = FncType, FncName extends string = string> extends CallType<FncT, FncName> {
+                    nodeId: string;
+                }
+                export interface SocketFunctionHook {
+                    (config: HookContext): MaybePromise<void>;
+                    /** NOTE: This is useful when we need a clientside hook to set up state specifically for our serverside hook. */
+                    clientHook?: SocketFunctionClientHook;
+                }
+                export type HookContext = {
+                    call: FullCallType;
+                    overrideResult?: unknown;
+                    onResult: ((result: unknown) => MaybePromise<void>)[];
+                };
+                export type ClientHookContext = {
+                    call: FullCallType;
+                    overrideResult?: unknown;
+                    onResult: ((result: unknown) => MaybePromise<void>)[];
+                    connectionId: {
+                        nodeId: string;
+                    };
+                };
+                export interface SocketFunctionClientHook {
+                    (config: ClientHookContext): MaybePromise<void>;
+                }
+                export interface SocketRegisterType<ExposedType = any> {
+                    _classGuid: string;
+                    _internalType: ExposedType;
+                }
+                export interface SocketRegistered<ExposedType = any> {
+                    nodes: {
+                        [nodeId: string]: {
+                            [functionName in keyof ExposedType]: ExposedType[functionName] & {
+                                [getCallObj]: (...args: Args<ExposedType[functionName]>) => FullCallType;
+                            };
+                        };
+                    };
+                    _classGuid: string;
+                    _internalType: ExposedType;
+                }
+                export type ControllerPick<T extends SocketRegistered, K extends keyof T["_internalType"]> = (SocketRegistered<Pick<T["_internalType"], K>>);
+                export type CallerContext = Readonly<CallerContextBase>;
+                export type CallerContextBase = {
+                    nodeId: string;
+                    localNodeId: string;
+                };
+
+            }
+
+            declare module "socket-function/hot/HotReloadController" {
+                /// <reference path="../../typenode/index.d.ts" />
+                /// <reference path="../require/RequireController.d.ts" />
+                /** Enables some hot reload functionality.
+                 *      - Triggers a refresh clientside
+                 *      - Triggers a reload server, for modules marked with `module.hotreload`
+                 */
+                export declare function watchFilesAndTriggerHotReloading(noAutomaticBrowserWatch?: boolean): void;
+                declare global {
+                    namespace NodeJS {
+                        interface Module {
+                            /** Causes us to hotreload the file. Applies both serverside and clientside.
+                             *      - If not set for any files clientside, we will refresh.
+                             *      - If not set for any files serverside, we will do nothing (and just leave old code running).
+                             */
+                            hotreload?: boolean;
+                            /** Overrides hotreload to disable hot reloading. Useful if you add "hotreload.flag" to a directory
+                             *      (which sets hotreload on all files in and under that directory), but want a specific file
+                             *      to not hotreload.
+                             *  - Also useful if you want files to hotreload clientside, but not serverside.
+                             */
+                            noserverhotreload?: boolean;
+                            watchAdditionalFiles?: string[];
+                        }
+                    }
+                    var isHotReloading: (() => boolean) | undefined;
+                }
+                export declare function isHotReloading(): boolean;
+                export declare function hotReloadingGuard(): true;
+                export declare function setExternalHotReloading(value: boolean): void;
+                export declare function onHotReload(callback: (modules: NodeJS.Module[]) => void): void;
+                export declare const HotReloadController: import("../SocketFunctionTypes").SocketRegistered<{
+                    watchFiles: () => Promise<void>;
+                    fileUpdated: (files: string[], changeTime: number) => Promise<void>;
+                }>;
+
+            }
+
+            declare module "socket-function/index" {
+                // Auto-generated file. Do not edit manually.
+                // Generated by: yarn generate-index-dts
+
+                declare module "socket-function/SetProcessVariables" {
+                    export {};
+
+                }
+
+                declare module "socket-function/SocketFunction" {
+                    /// <reference path="require/RequireController.d.ts" />
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "./SocketFunctionTypes";
+                    import { SocketServerConfig } from "./src/webSocketServer";
+                    import { Args, MaybePromise } from "./src/types";
+                    import "./SetProcessVariables";
+                    type ExtractShape<ClassType, Shape> = {
+                        [key in keyof ClassType]: (key extends keyof Shape ? ClassType[key] extends SocketExposedInterface[""] ? ClassType[key] : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never : "Function has implementation but is not exposed in the SocketFunction.register call");
+                    };
+                    export declare class SocketFunction {
+                        static logMessages: boolean;
+                        static trackMessageSizes: {
+                            upload: ((size: number) => void)[];
+                            download: ((size: number) => void)[];
+                            callTimes: ((obj: {
+                                start: number;
+                                end: number;
+                            }) => void)[];
+                        };
+                        static MAX_MESSAGE_SIZE: number;
+                        static HTTP_ETAG_CACHE: boolean;
+                        static silent: boolean;
+                        static HTTP_COMPRESS: boolean;
+                        static COEP: string;
+                        static COOP: string;
+                        static readonly WIRE_SERIALIZER: {
+                            serialize: (obj: unknown) => MaybePromise<Buffer[]>;
+                            deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
+                        };
+                        static WIRE_WARN_TIME: number;
+                        private static onMountCallbacks;
+                        static exposedClasses: Set<string>;
+                        static callerContext: CallerContext | undefined;
+                        static getCaller(): CallerContext;
+                        static harvestFailedCallCount: () => number;
+                        static getPendingCallCount: () => number;
+                        static harvestCallTimes: () => {
+                            start: number;
+                            end: number;
+                        }[];
+                        static register<ClassInstance extends object, Shape extends SocketExposedShape<{
+                            [key in keyof ClassInstance]: (...args: any[]) => Promise<unknown>;
+                        }>, Statics>(classGuid: string, instance: ClassInstance | (() => ClassInstance), shapeFnc: () => Shape, defaultHooksFnc?: () => SocketExposedShape[""] & {
+                            onMount?: () => MaybePromise<void>;
+                        }, config?: {
+                            /** @noAutoExpose If true SocketFunction.expose(Controller) must be called explicitly. */
+                            noAutoExpose?: boolean;
+                            statics?: Statics;
+                            /** Skip timing functions calls. Useful if a lot of functions have wait time that
+                                    is unrelated to processing, and therefore their timings won't be useful.
+                                    - Also useful if our auto function wrapping code is breaking functionality,
+                                        such as if you have a singleton function which you compare with ===,
+                                        which will breaks because we replaced it with a wrapped measure function.
+                            */
+                            noFunctionMeasure?: boolean;
+                        }): SocketRegistered<ExtractShape<ClassInstance, Shape>> & Statics;
+                        private static socketCache;
+                        static rehydrateSocketCaller<Controller>(socketRegistered: SocketRegisterType<Controller>, shapeFnc?: () => SocketExposedShape): SocketRegistered<Controller>;
+                        private static callFromGuid;
+                        static onNextDisconnect(nodeId: string, callback: () => void): void;
+                        static getLastDisconnectTime(nodeId: string): number | undefined;
+                        static isNodeConnected(nodeId: string): boolean;
+                        /** NOTE: Only works if the nodeIs used is from SocketFunction.connect (we can't convert arbitrary nodeIds into urls,
+                         *      as we have no way of knowing how to contain a nodeId).
+                         *  */
+                        static getHTTPCallLink(call: FullCallType): string;
+                        private static ignoreExposeCount;
+                        static ignoreExposeCalls<T>(code: () => Promise<T>): Promise<T>;
+                        /** Expose should be called before your mounting occurs. It mostly just exists to ensure you include the class type,
+                         *      so the class type's module construction runs, which should trigger register. Otherwise you would have
+                         *      to add additional imports to ensure the register call runs.
+                         */
+                        static expose(socketRegistered: SocketRegistered): void;
+                        static mountedNodeId: string;
+                        static isMounted(): boolean;
+                        static mountedIP: string;
+                        private static hasMounted;
+                        private static onMountCallback;
+                        static mountPromise: Promise<void>;
+                        static mount(config: SocketServerConfig): Promise<string>;
+                        /** Sets the default call when an http request is made, but no classGuid is set.
+                         *      NOTE: All other calls should be endpoint calls, even if those endpoints return a static file with an HTML content type.
+                         *          - However, to load new content, you should probably just use `require("./example.ts")`, which works on any files
+                         *              clientside that have also been required serverside (and whitelisted with module.allowclient = true,
+                         *              or with an `allowclient.flag` file in the directory or parent directory).
+                        */
+                        static setDefaultHTTPCall<Registered extends SocketRegistered, FunctionName extends keyof Registered["nodes"][""] & string>(registered: Registered, functionName: FunctionName, ...args: Args<Registered["nodes"][""][FunctionName]>): void;
+                        static connect(location: {
+                            address: string;
+                            port: number;
+                        }): string;
+                        static browserNodeId(): string;
+                        static getBrowserNodeId(): string;
+                        static addGlobalHook(hook: SocketFunctionHook): void;
+                        static addGlobalClientHook(hook: SocketFunctionClientHook): void;
+                    }
+                    declare global {
+                        var BOOTED_EDGE_NODE: {
+                            host: string;
+                        } | undefined;
+                    }
+                    export declare function _setSocketContext<T>(caller: CallerContext, code: () => T): T;
+                    export {};
+
+                }
+
+                declare module "socket-function/SocketFunctionTypes" {
+                    /// <reference path="require/RequireController.d.ts" />
+                    import { getCallObj } from "./src/nodeProxy";
+                    import { Args, MaybePromise } from "./src/types";
+                    export declare const socket: unique symbol;
+                    export type SocketExposedInterface = {
+                        [functionName: string]: (...args: any[]) => Promise<unknown>;
+                    };
+                    export type SocketInternalInterface = {
+                        [functionName: string]: {
+                            [getCallObj]: (...args: any[]) => FullCallType;
+                            (...args: any[]): Promise<unknown>;
+                        };
+                    };
+                    export type SocketExposedInterfaceClass = {
+                        new (): unknown;
+                        prototype: unknown;
+                    };
+                    export type FunctionFlags = {
+                        compress?: boolean;
+                        /** Indicates with the same input, we give the same output, forever,
+                         *      independent of code changes. This only works for data storage.
+                         */
+                        dataImmutable?: boolean;
+                        /** Allows overriding SocketFunction.MAX_MESSAGE_SIZE for responses from this function. */
+                        responseLimit?: number;
+                    };
+                    export type SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
+                        [functionName in keyof ExposedType]?: FunctionFlags & {
+                            hooks?: SocketFunctionHook[];
+                            clientHooks?: SocketFunctionClientHook[];
+                            noDefaultHooks?: boolean;
+                            /** BUG: I think this is broken if it is on the default hooks function? */
+                            noClientHooks?: boolean;
+                        };
+                    };
+                    export type FncType = (...args: any[]) => Promise<unknown>;
+                    export interface CallType<FncT extends FncType = FncType, FncName extends string = string> {
+                        classGuid: string;
+                        functionName: FncName;
+                        args: unknown[];
+                    }
+                    export interface FullCallType<FncT extends FncType = FncType, FncName extends string = string> extends CallType<FncT, FncName> {
+                        nodeId: string;
+                    }
+                    export interface SocketFunctionHook {
+                        (config: HookContext): MaybePromise<void>;
+                        /** NOTE: This is useful when we need a clientside hook to set up state specifically for our serverside hook. */
+                        clientHook?: SocketFunctionClientHook;
+                    }
+                    export type HookContext = {
+                        call: FullCallType;
+                        overrideResult?: unknown;
+                        onResult: ((result: unknown) => MaybePromise<void>)[];
+                    };
+                    export type ClientHookContext = {
+                        call: FullCallType;
+                        overrideResult?: unknown;
+                        onResult: ((result: unknown) => MaybePromise<void>)[];
+                        connectionId: {
+                            nodeId: string;
+                        };
+                    };
+                    export interface SocketFunctionClientHook {
+                        (config: ClientHookContext): MaybePromise<void>;
+                    }
+                    export interface SocketRegisterType<ExposedType = any> {
+                        _classGuid: string;
+                        _internalType: ExposedType;
+                    }
+                    export interface SocketRegistered<ExposedType = any> {
+                        nodes: {
+                            [nodeId: string]: {
+                                [functionName in keyof ExposedType]: ExposedType[functionName] & {
+                                    [getCallObj]: (...args: Args<ExposedType[functionName]>) => FullCallType;
+                                };
+                            };
+                        };
+                        _classGuid: string;
+                        _internalType: ExposedType;
+                    }
+                    export type ControllerPick<T extends SocketRegistered, K extends keyof T["_internalType"]> = (SocketRegistered<Pick<T["_internalType"], K>>);
+                    export type CallerContext = Readonly<CallerContextBase>;
+                    export type CallerContextBase = {
+                        nodeId: string;
+                        localNodeId: string;
+                    };
+
+                }
+
+                declare module "socket-function/hot/HotReloadController" {
+                    /// <reference path="../../typenode/index.d.ts" />
+                    /// <reference path="../require/RequireController.d.ts" />
+                    /** Enables some hot reload functionality.
+                     *      - Triggers a refresh clientside
+                     *      - Triggers a reload server, for modules marked with `module.hotreload`
+                     */
+                    export declare function watchFilesAndTriggerHotReloading(noAutomaticBrowserWatch?: boolean): void;
+                    declare global {
+                        namespace NodeJS {
+                            interface Module {
+                                /** Causes us to hotreload the file. Applies both serverside and clientside.
+                                 *      - If not set for any files clientside, we will refresh.
+                                 *      - If not set for any files serverside, we will do nothing (and just leave old code running).
+                                 */
+                                hotreload?: boolean;
+                                /** Overrides hotreload to disable hot reloading. Useful if you add "hotreload.flag" to a directory
+                                 *      (which sets hotreload on all files in and under that directory), but want a specific file
+                                 *      to not hotreload.
+                                 *  - Also useful if you want files to hotreload clientside, but not serverside.
+                                 */
+                                noserverhotreload?: boolean;
+                                watchAdditionalFiles?: string[];
+                            }
+                        }
+                        var isHotReloading: (() => boolean) | undefined;
+                    }
+                    export declare function isHotReloading(): boolean;
+                    export declare function hotReloadingGuard(): true;
+                    export declare function setExternalHotReloading(value: boolean): void;
+                    export declare function onHotReload(callback: (modules: NodeJS.Module[]) => void): void;
+                    export declare const HotReloadController: import("../SocketFunctionTypes").SocketRegistered<{
+                        watchFiles: () => Promise<void>;
+                        fileUpdated: (files: string[], changeTime: number) => Promise<void>;
+                    }>;
+
+                }
+
+                declare module "socket-function/index" {
+                    // Auto-generated file. Do not edit manually.
+                    // Generated by: yarn generate-index-dts
+
+                    declare module "socket-function/SetProcessVariables" {
+                        export {};
+
+                    }
+
+                    declare module "socket-function/SocketFunction" {
+                        /// <reference path="require/RequireController.d.ts" />
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "./SocketFunctionTypes";
+                        import { SocketServerConfig } from "./src/webSocketServer";
+                        import { Args, MaybePromise } from "./src/types";
+                        import "./SetProcessVariables";
+                        type ExtractShape<ClassType, Shape> = {
+                            [key in keyof ClassType]: (key extends keyof Shape ? ClassType[key] extends SocketExposedInterface[""] ? ClassType[key] : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never : "Function is in shape, but not in class");
+                        };
+                        export declare class SocketFunction {
+                            static logMessages: boolean;
+                            static trackMessageSizes: {
+                                upload: ((size: number) => void)[];
+                                download: ((size: number) => void)[];
+                                callTimes: ((obj: {
+                                    start: number;
+                                    end: number;
+                                }) => void)[];
+                            };
+                            static MAX_MESSAGE_SIZE: number;
+                            static HTTP_ETAG_CACHE: boolean;
+                            static silent: boolean;
+                            static HTTP_COMPRESS: boolean;
+                            static COEP: string;
+                            static COOP: string;
+                            static readonly WIRE_SERIALIZER: {
+                                serialize: (obj: unknown) => MaybePromise<Buffer[]>;
+                                deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
+                            };
+                            static WIRE_WARN_TIME: number;
+                            private static onMountCallbacks;
+                            static exposedClasses: Set<string>;
+                            static callerContext: CallerContext | undefined;
+                            static getCaller(): CallerContext;
+                            static harvestFailedCallCount: () => number;
+                            static getPendingCallCount: () => number;
+                            static harvestCallTimes: () => {
+                                start: number;
+                                end: number;
+                            }[];
+                            static register<ClassInstance extends object, Shape extends SocketExposedShape<{
+                                [key in keyof ClassInstance]: (...args: any[]) => Promise<unknown>;
+                            }>, Statics>(classGuid: string, instance: ClassInstance | (() => ClassInstance), shapeFnc: () => Shape, defaultHooksFnc?: () => SocketExposedShape[""] & {
+                                onMount?: () => MaybePromise<void>;
+                            }, config?: {
+                                /** @noAutoExpose If true SocketFunction.expose(Controller) must be called explicitly. */
+                                noAutoExpose?: boolean;
+                                statics?: Statics;
+                                /** Skip timing functions calls. Useful if a lot of functions have wait time that
+                                        is unrelated to processing, and therefore their timings won't be useful.
+                                        - Also useful if our auto function wrapping code is breaking functionality,
+                                            such as if you have a singleton function which you compare with ===,
+                                            which will breaks because we replaced it with a wrapped measure function.
+                                */
+                                noFunctionMeasure?: boolean;
+                            }): SocketRegistered<ExtractShape<ClassInstance, Shape>> & Statics;
+                            private static socketCache;
+                            static rehydrateSocketCaller<Controller>(socketRegistered: SocketRegisterType<Controller>, shapeFnc?: () => SocketExposedShape): SocketRegistered<Controller>;
+                            private static callFromGuid;
+                            static onNextDisconnect(nodeId: string, callback: () => void): void;
+                            static getLastDisconnectTime(nodeId: string): number | undefined;
+                            static isNodeConnected(nodeId: string): boolean;
+                            /** NOTE: Only works if the nodeIs used is from SocketFunction.connect (we can't convert arbitrary nodeIds into urls,
+                             *      as we have no way of knowing how to contain a nodeId).
+                             *  */
+                            static getHTTPCallLink(call: FullCallType): string;
+                            private static ignoreExposeCount;
+                            static ignoreExposeCalls<T>(code: () => Promise<T>): Promise<T>;
+                            /** Expose should be called before your mounting occurs. It mostly just exists to ensure you include the class type,
+                             *      so the class type's module construction runs, which should trigger register. Otherwise you would have
+                             *      to add additional imports to ensure the register call runs.
+                             */
+                            static expose(socketRegistered: SocketRegistered): void;
+                            static mountedNodeId: string;
+                            static isMounted(): boolean;
+                            static mountedIP: string;
+                            private static hasMounted;
+                            private static onMountCallback;
+                            static mountPromise: Promise<void>;
+                            static mount(config: SocketServerConfig): Promise<string>;
+                            /** Sets the default call when an http request is made, but no classGuid is set.
+                             *      NOTE: All other calls should be endpoint calls, even if those endpoints return a static file with an HTML content type.
+                             *          - However, to load new content, you should probably just use `require("./example.ts")`, which works on any files
+                             *              clientside that have also been required serverside (and whitelisted with module.allowclient = true,
+                             *              or with an `allowclient.flag` file in the directory or parent directory).
+                            */
+                            static setDefaultHTTPCall<Registered extends SocketRegistered, FunctionName extends keyof Registered["nodes"][""] & string>(registered: Registered, functionName: FunctionName, ...args: Args<Registered["nodes"][""][FunctionName]>): void;
+                            static connect(location: {
+                                address: string;
+                                port: number;
+                            }): string;
+                            static browserNodeId(): string;
+                            static getBrowserNodeId(): string;
+                            static addGlobalHook(hook: SocketFunctionHook): void;
+                            static addGlobalClientHook(hook: SocketFunctionClientHook): void;
+                        }
+                        declare global {
+                            var BOOTED_EDGE_NODE: {
+                                host: string;
+                            } | undefined;
+                        }
+                        export declare function _setSocketContext<T>(caller: CallerContext, code: () => T): T;
+                        export {};
+
+                    }
+
+                    declare module "socket-function/SocketFunctionTypes" {
+                        /// <reference path="require/RequireController.d.ts" />
+                        import { getCallObj } from "./src/nodeProxy";
+                        import { Args, MaybePromise } from "./src/types";
+                        export declare const socket: unique symbol;
+                        export type SocketExposedInterface = {
+                            [functionName: string]: (...args: any[]) => Promise<unknown>;
+                        };
+                        export type SocketInternalInterface = {
+                            [functionName: string]: {
+                                [getCallObj]: (...args: any[]) => FullCallType;
+                                (...args: any[]): Promise<unknown>;
+                            };
+                        };
+                        export type SocketExposedInterfaceClass = {
+                            new (): unknown;
+                            prototype: unknown;
+                        };
+                        export type FunctionFlags = {
+                            compress?: boolean;
+                            /** Indicates with the same input, we give the same output, forever,
+                             *      independent of code changes. This only works for data storage.
+                             */
+                            dataImmutable?: boolean;
+                            /** Allows overriding SocketFunction.MAX_MESSAGE_SIZE for responses from this function. */
+                            responseLimit?: number;
+                        };
+                        export type SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
+                            [functionName in keyof ExposedType]?: FunctionFlags & {
+                                hooks?: SocketFunctionHook[];
+                                clientHooks?: SocketFunctionClientHook[];
+                                noDefaultHooks?: boolean;
+                                /** BUG: I think this is broken if it is on the default hooks function? */
+                                noClientHooks?: boolean;
+                            };
+                        };
+                        export type FncType = (...args: any[]) => Promise<unknown>;
+                        export interface CallType<FncT extends FncType = FncType, FncName extends string = string> {
+                            classGuid: string;
+                            functionName: FncName;
+                            args: unknown[];
+                        }
+                        export interface FullCallType<FncT extends FncType = FncType, FncName extends string = string> extends CallType<FncT, FncName> {
+                            nodeId: string;
+                        }
+                        export interface SocketFunctionHook {
+                            (config: HookContext): MaybePromise<void>;
+                            /** NOTE: This is useful when we need a clientside hook to set up state specifically for our serverside hook. */
+                            clientHook?: SocketFunctionClientHook;
+                        }
+                        export type HookContext = {
+                            call: FullCallType;
+                            overrideResult?: unknown;
+                            onResult: ((result: unknown) => MaybePromise<void>)[];
+                        };
+                        export type ClientHookContext = {
+                            call: FullCallType;
+                            overrideResult?: unknown;
+                            onResult: ((result: unknown) => MaybePromise<void>)[];
+                            connectionId: {
+                                nodeId: string;
+                            };
+                        };
+                        export interface SocketFunctionClientHook {
+                            (config: ClientHookContext): MaybePromise<void>;
+                        }
+                        export interface SocketRegisterType<ExposedType = any> {
+                            _classGuid: string;
+                            _internalType: ExposedType;
+                        }
+                        export interface SocketRegistered<ExposedType = any> {
+                            nodes: {
+                                [nodeId: string]: {
+                                    [functionName in keyof ExposedType]: ExposedType[functionName] & {
+                                        [getCallObj]: (...args: Args<ExposedType[functionName]>) => FullCallType;
+                                    };
+                                };
+                            };
+                            _classGuid: string;
+                            _internalType: ExposedType;
+                        }
+                        export type ControllerPick<T extends SocketRegistered, K extends keyof T["_internalType"]> = (SocketRegistered<Pick<T["_internalType"], K>>);
+                        export type CallerContext = Readonly<CallerContextBase>;
+                        export type CallerContextBase = {
+                            nodeId: string;
+                            localNodeId: string;
+                        };
+
+                    }
+
+                    declare module "socket-function/hot/HotReloadController" {
+                        /// <reference path="../../typenode/index.d.ts" />
+                        /// <reference path="../require/RequireController.d.ts" />
+                        /** Enables some hot reload functionality.
+                         *      - Triggers a refresh clientside
+                         *      - Triggers a reload server, for modules marked with `module.hotreload`
+                         */
+                        export declare function watchFilesAndTriggerHotReloading(noAutomaticBrowserWatch?: boolean): void;
+                        declare global {
+                            namespace NodeJS {
+                                interface Module {
+                                    /** Causes us to hotreload the file. Applies both serverside and clientside.
+                                     *      - If not set for any files clientside, we will refresh.
+                                     *      - If not set for any files serverside, we will do nothing (and just leave old code running).
+                                     */
+                                    hotreload?: boolean;
+                                    /** Overrides hotreload to disable hot reloading. Useful if you add "hotreload.flag" to a directory
+                                     *      (which sets hotreload on all files in and under that directory), but want a specific file
+                                     *      to not hotreload.
+                                     *  - Also useful if you want files to hotreload clientside, but not serverside.
+                                     */
+                                    noserverhotreload?: boolean;
+                                    watchAdditionalFiles?: string[];
+                                }
+                            }
+                            var isHotReloading: (() => boolean) | undefined;
+                        }
+                        export declare function isHotReloading(): boolean;
+                        export declare function hotReloadingGuard(): true;
+                        export declare function setExternalHotReloading(value: boolean): void;
+                        export declare function onHotReload(callback: (modules: NodeJS.Module[]) => void): void;
+                        export declare const HotReloadController: import("../SocketFunctionTypes").SocketRegistered<{
+                            watchFiles: () => Promise<void>;
+                            fileUpdated: (files: string[], changeTime: number) => Promise<void>;
+                        }>;
+
+                    }
+
+                    declare module "socket-function/index" {
+                        /// <reference path="./node_modules/typenode/index.d.ts" />
+
+                        export { };
+
+                        declare global {
+                            namespace NodeJS {
+                                interface Module {
+                                    original?: SerializedModule;
+                                }
+                            }
+                            interface SerializedModule {
+                                originalId: string;
+                                filename: string;
+                                // If a module is not allowed clientside it is likely requests will be empty,
+                                //  to save effort parsing requests for modules that only exist to give better
+                                //  error messages.
+                                requests: {
+                                    // request => resolvedPath
+                                    [request: string]: string;
+                                };
+                                asyncRequests: { [request: string]: true };
+                                // NOTE: IF !allowclient && !serveronly, it might just mean we didn't add allowclient
+                                //  to the module yet. BUT, if serveronly, then we know for sure we don't want it client.
+                                //  So the messages and behavior will be different.
+                                allowclient?: boolean;
+                                serveronly?: boolean;
+                                // Just for errors mostly
+                                alwayssend?: boolean;
+
+                                /** Only set if allowclient. */
+                                source?: string;
+
+                                seqNum: number;
+
+                                size?: number;
+                                version?: number;
+
+                                flags?: {
+                                    [flag: string]: true;
+                                };
+                            }
+
+                        }
+                    }
+
+                    declare module "socket-function/mobx/UrlParam" {
+                        export declare class UrlParam<T> {
+                            private key;
+                            private defaultValue;
+                            constructor(key: string, defaultValue: T);
+                            valueSeqNum: {
+                                value: number;
+                            };
+                            get(): T;
+                            set(value: T): void;
+                            reset(): void;
+                            get value(): T;
+                            set value(value: T);
+                        }
+
+                    }
+
+                    declare module "socket-function/mobx/observer" {
+                        import type preact from "preact";
+                        import { Reaction } from "mobx";
+                        export declare function observer<T extends {
+                            new (...args: any[]): {
+                                render(): preact.ComponentChild;
+                                forceUpdate(callback?: () => void): void;
+                                componentWillUnmount?(): void;
+                            };
+                        }>(Constructor: T): {
+                            new (...args: any[]): {
+                                constructOrder: number;
+                                reaction: Reaction;
+                                componentWillUnmount(): void;
+                                render(): preact.ComponentChild;
+                                forceUpdate(callback?: () => void): void;
+                            };
+                            readonly name: string;
+                        } & T;
+
+                    }
+
+                    declare module "socket-function/mobx/promiseToObservable" {
+                        export interface InternalResult {
+                            result: {
+                                value: unknown;
+                            } | undefined;
+                        }
+                        export declare function promiseToObservable<T>(promise: Promise<T>, staleValue?: T): {
+                            value: T | undefined;
+                        };
+
+                    }
+
+                    declare module "socket-function/require/CSSShim" {
+                        /// <reference path="RequireController.d.ts" />
+                        export {};
+
+                    }
+
+                    declare module "socket-function/require/compileFlags" {
+                        /// <reference path="RequireController.d.ts" />
+                        /// <reference types="node" />
+                        /**
+                         *      Adds a global function setFlag(require, "typescript", flag) which sets a flag on the client
+                         *          - Ex, setFlag(require, "typescript", "allowclient") so allowclient = true on the typescript module.
+                         *          - Passing true as the fourth argument sets it recursively
+                         */
+                        export declare const forceModule = true;
+                        declare global {
+                        }
+                        export declare function setFlag(require: NodeRequire, request: string, flag: string, recursive?: boolean): void;
+
+                    }
+
+                    declare module "socket-function/require/extMapper" {
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        export declare function getExtContentType(ext: string): string;
+                        export declare function getContentTypeFromBuffer(buffer: Buffer): string | undefined;
+
+                    }
+
+                    declare module "socket-function/require/require" {
+                        /// <reference path="../index.d.ts" />
+                        declare global {
+                            var onProgressHandler: undefined | ((progress: {
+                                type: string;
+                                addValue: number;
+                                addMax: number;
+                            }) => void);
+                            var onErrorHandler: undefined | ((error: string) => void);
+                            var BOOT_TIME: number;
+                            var builtInModuleExports: {
+                                [key: string]: unknown;
+                            };
+                        }
+                        export declare function requireMain(): void;
+
+                    }
+
+                    declare module "socket-function/src/CallFactory" {
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        import { CallType } from "../SocketFunctionTypes";
+                        import * as ws from "ws";
+                        import * as tls from "tls";
+                        export interface CallFactory {
+                            nodeId: string;
+                            lastClosed: number;
+                            closedForever?: boolean;
+                            isConnected?: boolean;
+                            performCall(call: CallType): Promise<unknown>;
+                            onNextDisconnect(callback: () => void): void;
+                            connectionId: {
+                                nodeId: string;
+                            };
+                        }
+                        export interface SenderInterface {
+                            nodeId?: string;
+                            _socket?: tls.TLSSocket;
+                            send(data: string | Buffer): void;
+                            addEventListener(event: "open", listener: () => void): void;
+                            addEventListener(event: "close", listener: () => void): void;
+                            addEventListener(event: "error", listener: (err: {
+                                message: string;
+                            }) => void): void;
+                            addEventListener(event: "message", listener: (data: ws.RawData | ws.MessageEvent | string) => void): void;
+                            readyState: number;
+                            ping?(): void;
+                        }
+                        export declare function harvestFailedCallCount(): number;
+                        export declare function getPendingCallCount(): number;
+                        export declare function harvestCallTimes(): {
+                            start: number;
+                            end: number;
+                        }[];
+                        export declare function createCallFactory(webSocketBase: SenderInterface | undefined, nodeId: string, localNodeId?: string): Promise<CallFactory>;
+
+                    }
+
+                    declare module "socket-function/src/JSONLACKS/JSONLACKS" {
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        export interface JSONLACKS_ParseConfig {
+                            extended?: boolean;
+                            discardMissingReferences?: boolean;
+                        }
+                        export interface JSONLACKS_StringifyConfig {
+                            allowObjectMutation?: boolean;
+                        }
+                        interface HydrateState {
+                            references: Map<string, unknown>;
+                            visited: Set<unknown>;
+                        }
+                        export declare class JSONLACKS {
+                            static readonly LACKS_KEY = "__JSONLACKS__98cfb4a05fa34d828661cae15b8779ce__";
+                            /** If set to true parses non-quoted field names, comments, trailing commas, etc */
+                            static EXTENDED_PARSER: boolean;
+                            static IGNORE_MISSING_REFERENCES: boolean;
+                            static stringify(obj: unknown, config?: JSONLACKS_StringifyConfig): string;
+                            /** Is useful when serializing an array to a file with one object per line */
+                            static stringifyFile(obj: unknown[], config?: JSONLACKS_StringifyConfig): Promise<Buffer>;
+                            static stringifyFileSync(obj: unknown[], config?: JSONLACKS_StringifyConfig): Buffer;
+                            static parse<T>(text: string, config?: JSONLACKS_ParseConfig, hydrateState?: HydrateState): T;
+                            static parseLines<T>(buffer: Buffer, config?: JSONLACKS_ParseConfig): Promise<T[]>;
+                            private static escapeSpecialObjects;
+                            private static hydrateSpecialObjects;
+                        }
+                        export {};
+
+                    }
+
+                    declare module "socket-function/src/JSONLACKS/JSONLACKS.generated.js" {
+                        export function parse(text: string): unknown;
+                    }
+
+                    declare module "socket-function/src/args" {
+                        export declare const getArgs: {
+                            (): {
+                                [key: string]: string | undefined;
+                            };
+                            reset(): void;
+                            set(newValue: {
+                                [key: string]: string | undefined;
+                            }): void;
+                        };
+
+                    }
+
+                    declare module "socket-function/src/batching" {
+                        import { AnyFunction } from "./types";
+                        export type DelayType = (number | "afterio" | "immediate" | "afterpromises" | "paintLoop" | "afterPaint");
+                        export declare function delay(delayTime: DelayType, immediateShortDelays?: "immediateShortDelays"): Promise<void>;
+                        export declare function batchFunctionNone<Arg, Result = void>(config: unknown, fnc: (arg: Arg[]) => (Promise<Result> | Result)): (arg: Arg) => Promise<Result>;
+                        export declare function batchFunction<Arg, Result = void>(config: {
+                            delay: DelayType;
+                            /** Instead of immediately waiting delay, starts by waiting 0ms, and every call increments the delay factor
+                             *      by 1. Delay is `factor * (delay / throttleWindow)`. For every delay interval we have no calls, we decrease by
+                             *      no_calls/delay.
+                             *      - This essentially turns delay into a `calls per second` type indicator (ex, 10ms is 100 callers
+                             *          per second, 500ms is 2 calls, etc), which is accurate over delay * throttleWindow time.
+                             */
+                            throttleWindow?: number;
+                            name?: string;
+                            noMeasure?: boolean;
+                        }, fnc: (arg: Arg[]) => (Promise<Result> | Result)): (arg: Arg) => Promise<Result>;
+                        export declare function runInSerial<T extends (...args: any[]) => Promise<any>>(fnc: T): T;
+                        export declare function runInParallel<T extends (...args: any[]) => Promise<any>>(config: {
+                            parallelCount: number;
+                            callTimeout?: number;
+                        }, fnc: T): T;
+                        export declare function runInfinitePoll(delayTime: number, fnc: () => Promise<void> | void): void;
+                        export declare function runInfinitePollCallAtStart(delayTime: number, fnc: () => Promise<void> | void): Promise<void>;
+                        /** Disables polling, called on shutdown. Blocks until all pending poll loops finish */
+                        export declare function shutdownPolling(): Promise<void>;
+                        export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?: {
+                            maxRetries?: number;
+                            shouldRetry?: (message: string) => boolean;
+                            minDelay?: number;
+                            maxDelay?: number;
+                        }): T;
+
+                    }
+
+                    declare module "socket-function/src/caching" {
+                        import { AnyFunction, Args } from "./types";
+                        export declare function lazy<T>(factory: () => T): {
+                            (): T;
+                            reset(): void;
+                            set(newValue: T): void;
+                        };
+                        export declare function cacheEmptyArray<T>(array: T[]): T[];
+                        export declare function cache<Output, Key, Untracked extends unknown[]>(getValue: (key: Key, ...untracked: Untracked) => Output): {
+                            (key: Key, ...untracked: Untracked): Output;
+                            clear(key: Key): void;
+                            clearAll(): void;
+                            forceSet(key: Key, value: Output): void;
+                            getAllKeys(): Key[];
+                            get(key: Key): Output | undefined;
+                        };
+                        /** Makes a cache that limits the number of entries, allowing you to put arbitrary data in it
+                         *      without worrying about leaking memory
+                          */
+                        export declare function cacheLimited<Output, Key>(maxCount: number, getValue: (key: Key) => Output): {
+                            (input: Key): Output;
+                            forceSet(key: Key, value: Output): void;
+                            clearKey(key: Key): void;
+                            clear(): void;
+                        };
+                        export declare function cacheWeak<Output, Key extends object>(getValue: (key: Key) => Output): (key: Key) => Output;
+                        export declare function cacheList<Value>(getLength: () => number, getValue: (index: number) => Value): {
+                            (index: number): Value;
+                        };
+                        /** A cache half way between caching based on === and caching based on hash. Caches
+                         *      based on arrayEqual, which does === on all values in an array. Requires localized
+                         *      caching (as the comparisons don't scale with many candidates, unlike hashing),
+                         *      however works with non trival transformations (ex, resolving many persisted overrides
+                         *      to get a value), unlike cache().
+                         *  Also, limits itself, more of a performance optimization than memory optimization, as it scales
+                         *      very poorly with the number of candidates.
+                         *
+                         *  TIMING: About 6us with limit = 100, array size = 294, and the cache being full.
+                         */
+                        export declare function cacheArrayEqual<Input extends unknown[] | undefined, Output>(map: (arrays: Input) => Output, limit?: number): {
+                            (array: Input): Output;
+                            clear(array: Input): void;
+                            clearAll(): void;
+                        };
+                        /** Caches when arguments are ===. See cacheArrayEqual */
+                        export declare function cacheArgsEqual<Fnc extends AnyFunction>(fnc: Fnc, limit?: number): Fnc & {
+                            clear(...args: Args<Fnc>): void;
+                        };
+                        export declare function cacheJSONArgsEqual<Fnc extends AnyFunction>(fnc: Fnc, limit?: number): Fnc & {
+                            clear(...args: unknown[]): void;
+                            clearAll(): void;
+                        };
+                        export declare function cacheShallowConfigArgEqual<Fnc extends AnyFunction>(fnc: Fnc, limit?: number): Fnc & {
+                            clear(configObj: Args<Fnc>[0]): void;
+                            clearAll(): void;
+                        };
+                        export declare function externalCache<Key, Value>(): {
+                            get: (key: Key) => Value | undefined;
+                            set: (key: Key, value: Value) => void;
+                        };
+
+                    }
+
+                    declare module "socket-function/src/callHTTPHandler" {
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        import http from "http";
+                        import { CallType } from "../SocketFunctionTypes";
+                        export declare function setDefaultHTTPCall(call: CallType): void;
+                        export declare function getServerLocationFromRequest(request: http.IncomingMessage): {
+                            address: string;
+                            port: number;
+                        };
+                        export declare function getNodeIdsFromRequest(request: http.IncomingMessage): {
+                            nodeId: string;
+                            localNodeId: string;
+                        };
+                        export declare function getCurrentHTTPRequest(): http.IncomingMessage | undefined;
+                        export declare function httpCallHandler(request: http.IncomingMessage, response: http.ServerResponse): Promise<void>;
+                        declare const resultHeaders: unique symbol;
+                        type HTTPResultType = Buffer & {
+                            [resultHeaders]?: {
+                                [header: string]: string;
+                            };
+                        };
+                        export declare function setHTTPResultHeaders(result: HTTPResultType, headers: {
+                            [header: string]: string;
+                        }): HTTPResultType;
+                        export {};
+
+                    }
+
+                    declare module "socket-function/src/callManager" {
+                        /// <reference path="../hot/HotReloadController.d.ts" />
+                        import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
+                        export declare function getCallFlags(call: CallType): FunctionFlags | undefined;
+                        export declare function shouldCompressCall(call: CallType): boolean;
+                        export declare function performLocalCall(config: {
+                            call: FullCallType;
+                            caller: CallerContext;
+                        }): Promise<unknown>;
+                        export declare function isDataImmutable(call: CallType): boolean;
+                        export declare function registerClass(classGuid: string, controller: SocketExposedInterface, shape: SocketExposedShape, config?: {
+                            noFunctionMeasure?: boolean;
+                        }): void;
+                        export declare function exposeClass(exposedClass: SocketRegistered): void;
+                        export declare function registerGlobalHook(hook: SocketFunctionHook): void;
+                        export declare function unregisterGlobalHook(hook: SocketFunctionHook): void;
+                        export declare function registerGlobalClientHook(hook: SocketFunctionClientHook): void;
+                        export declare function unregisterGlobalClientHook(hook: SocketFunctionClientHook): void;
+                        export declare const runClientHooks: (callType: FullCallType, hooks: Exclude<SocketExposedShape[""], undefined>, connectionId: {
+                            nodeId: string;
+                        }) => Promise<ClientHookContext>;
+                        export declare const runServerHooks: (callType: FullCallType, caller: CallerContext, hooks: Exclude<SocketExposedShape[""], undefined>) => Promise<HookContext>;
+
+                    }
+
+                    declare module "socket-function/src/certStore" {
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        /** Must be populated before the server starts */
+                        export declare function trustCertificate(cert: string | Buffer): void;
+                        export declare function getTrustedCertificates(): string[];
+                        export declare function watchTrustedCertificates(callback: (certs: string[]) => void): () => boolean;
+
+                    }
+
+                    declare module "socket-function/src/corsCheck" {
+
+                    }
+
+                    declare module "socket-function/src/fixLargeNetworkCalls" {
+                        export declare function markArrayAsSplitable<T>(data: T[]): T[];
+                        export declare function isSplitableArray<T>(data: T): data is T & (unknown[]);
+
+                    }
+
+                    declare module "socket-function/src/formatting/colors" {
+                        export type HSL = {
+                            h: number;
+                            s: number;
+                            l: number;
+                        };
+                        export declare function hslText(color: HSL): string;
+                        export declare function hslToRGB(color: HSL): {
+                            r: number;
+                            g: number;
+                            b: number;
+                        };
+                        export declare function hslToHex(color: HSL): string;
+                        export declare function hslLightenGamma(hsl: HSL, fraction: number): {
+                            h: number;
+                            s: number;
+                            l: number;
+                        };
+                        export declare function hslLightenLinear(hsl: HSL, lightness: number): {
+                            h: number;
+                            s: number;
+                            l: number;
+                        };
+                        export declare function hslDarkenGamma(hsl: HSL, fraction: number): {
+                            h: number;
+                            s: number;
+                            l: number;
+                        };
+                        export declare function hslDarkenLinear(hsl: HSL, lightness: number): {
+                            h: number;
+                            s: number;
+                            l: number;
+                        };
+                        export declare function hslAddSaturate(hsl: HSL, saturation: number): {
+                            h: number;
+                            s: number;
+                            l: number;
+                        };
+                        export declare function hslSetSaturate(hsl: HSL, saturation: number): {
+                            h: number;
+                            s: number;
+                            l: number;
+                        };
+
+                    }
+
+                    declare module "socket-function/src/formatting/format" {
+                        export declare function formatTime(milliseconds: number | undefined, maxAbsoluteValue?: number): string;
+                        export declare function getTargetDecimals(maxAbsoluteValue: number, targetDigits: number): number;
+                        /** Adds decimal digits to reach digits. If the number is simply too large, it won't remove
+                         *      digits, there will instead just be no decimal point.
+                         */
+                        export declare function formatMaxDecimals(num: number, targetDigits: number, maxAbsoluteValue?: number, exactDecimals?: number): string;
+                        /** Actually formats any number, including decimals, by using K, M and B suffixes to get smaller values
+                         *      TODO: Support uK, uM and uB suffixes for very small numbers?
+                         *      <= 6 characters (<= 5 if positive)
+                         */
+                        export declare function formatNumber(count: number | undefined, maxAbsoluteValue?: number, noDecimal?: boolean, specialCurrency?: boolean): string;
+                        export declare function formatBinaryNumber(count: number | undefined, maxAbsoluteValue?: number, noDecimal?: boolean, specialCurrency?: boolean): string;
+                        /** YYYY/MM/DD HH:MM:SS PM/AM */
+                        export declare function formatDateTime(time: number): string;
+                        export declare function formatDateTimeDetailed(time: number): string;
+                        export declare function formatFileTimestampLocal(time: number): string;
+                        /** 2024 January 1, Monday, 12:53:02pm */
+                        export declare function formatNiceDateTime(time: number): string;
+                        /** 2024 January 1, Monday, 12:53:02pm (4 months ago)  */
+                        export declare function formatVeryNiceDateTime(time: number): string;
+                        /** YYYY/MM/DD */
+                        export declare function formatDate(time: number): string;
+                        /** <= 6 characters (<= 5 if positive) */
+                        export declare function formatPercent(value: number): string;
+
+                    }
+
+                    declare module "socket-function/src/formatting/logColors" {
+                        export declare const blue: (text: string) => string;
+                        export declare const red: (text: string) => string;
+                        export declare const green: (text: string) => string;
+                        export declare const yellow: (text: string) => string;
+                        export declare const white: (text: string) => string;
+                        export declare const gray: (text: string) => string;
+                        export declare const magenta: (text: string) => string;
+
+                    }
+
+                    declare module "socket-function/src/forwardPort" {
+                        export declare function forwardPort(config: {
+                            externalPort: number;
+                            internalPort: number;
+                            duration?: number;
+                        }): Promise<void>;
+
+                    }
+
+                    declare module "socket-function/src/https" {
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], method?: string, sendSessionCookies?: boolean, config?: {
+                            headers?: {
+                                [key: string]: string | undefined;
+                            };
+                            cancel?: Promise<void>;
+                        }): Promise<Buffer>;
+
+                    }
+
+                    declare module "socket-function/src/misc" {
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        import { MaybePromise } from "./types";
+                        export declare const timeInSecond = 1000;
+                        export declare const timeInMinute: number;
+                        export declare const timeInHour: number;
+                        export declare const timeInDay: number;
+                        export declare const timeInWeek: number;
+                        export declare const timeInYear: number;
+                        export type Watchable<T> = (callback: (value: T) => void) => MaybePromise<void>;
+                        export declare function convertErrorStackToError(error: string): Error;
+                        export declare function sha256Hash(buffer: Buffer | string): string;
+                        export declare function sha256HashBuffer(buffer: Buffer | string): Buffer;
+                        /** Async, but works both clientside and serverside. */
+                        export declare function sha256HashPromise(buffer: Buffer): Promise<any>;
+                        export declare function sha256BufferPromise(buffer: Buffer): Promise<Buffer>;
+                        export declare function arrayEqual(a: {
+                            [key: number]: unknown;
+                            length: number;
+                        }, b: {
+                            [key: number]: unknown;
+                            length: number;
+                        }): boolean;
+                        export declare function isNode(): boolean;
+                        export declare function isNodeTrue(): true;
+                        export declare function formatNumberSuffixed(count: number): string;
+                        export declare function list(count: number): number[];
+                        export declare function recursiveFreeze<T>(obj: T): T;
+                        export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
+                        export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
+                        export declare function isBufferType(obj: unknown): obj is BufferType;
+                        export declare function getKeys(obj: unknown): PropertyKey[];
+                        export declare function getStringKeys<T extends {}>(obj: T): ((keyof T) & string)[];
+                        export declare function keyBy<T, K>(arr: T[], getKey: (value: T) => K): Map<K, T>;
+                        export declare function keyByArray<T, K>(arr: T[], getKey: (value: T) => K): Map<K, T[]>;
+                        export declare function deepCloneJSON<T>(obj: T): T;
+                        export declare class PromiseObj<T = void> {
+                            promise: Promise<T>;
+                            value: {
+                                value?: T;
+                                error?: string;
+                            } | undefined;
+                            /** Resolve called does not mean the value is ready, as it may be resolved with a promise. */
+                            resolveCalled?: boolean;
+                            resolve: (value: T | Promise<T>) => void;
+                            reject: (error: any) => void;
+                            private baseResolve;
+                            private baseReject;
+                            constructor();
+                        }
+                        export declare function promiseObj<T = void>(): PromiseObj<T>;
+                        export declare function throttleFunction<Args extends any[]>(delay: number, fnc: (...args: Args) => MaybePromise<void>): (...args: Args) => Promise<void>;
+                        export declare function nextId(): string;
+                        export declare function arrayFromOrderObject<T>(obj: {
+                            [order: number]: T;
+                        }): T[];
+                        export declare function last<T>(arr: T[]): T | undefined;
+                        export type ObjectValues<T> = T[keyof T];
+                        export declare function entries<Obj extends {
+                            [key: string]: unknown;
+                        }>(obj: Obj): [keyof Obj, ObjectValues<Obj>][];
+                        export declare function keys<Obj extends {
+                            [key: string]: unknown;
+                        }>(obj: Obj): (keyof Obj)[];
+                        export declare function sort<T>(arr: T[], sortKey: (obj: T) => unknown): T[];
+                        export declare function getRootDomain(hostname: string): string;
+                        export declare class QueueLimited<T> {
+                            private readonly maxCount;
+                            private items;
+                            private nextIndex;
+                            constructor(maxCount: number);
+                            push(item: T): void;
+                            getAllUnordered(): T[];
+                            reset(): void;
+                            clear(): void;
+                            getOldest(): T | undefined;
+                        }
+                        export declare function binarySearchBasic<T, V>(array: T[], getVal: (val: T) => V, searchValue: V): number;
+                        export declare function binarySearchBasic2<T, V>(array: T[], getVal: (val: T) => V, searchValue: T): number;
+                        /**
+                         *  Searches indexes, allowing you to query structures that aren't arrays. To search an array, use:
+                         *      `binarySearchIndex(array.length, i => compare(array[i], searchValue))`
+                         *
+                         *      NOTE: If there are duplicates, returns the first match.
+                         *
+                         *      NOTE: If the value can't be found, returns the bitwise negation of the index where it should be inserted.
+                         *
+                         *      NOTE: With `if (index < 0) index = ~index;` you will get an index of the value >= the target value.
+                         */
+                        export declare function binarySearchIndex(listCount: number, compare: (lhsIndex: number) => number): number;
+                        export declare function compare(lhs: unknown, rhs: unknown): number;
+                        export declare function compareArray(lhs: unknown[], rhs: unknown[]): number;
+                        export declare function insertIntoSortedList<T>(list: T[], map: (val: T) => string | number, element: T): void;
+                        export declare function removeFromSortedList<T>(list: T[], map: (val: T) => string | number, searchValue: string | number): void;
+                        export declare function timeoutToError<T>(time: number, p: Promise<T>, err: () => Error): Promise<T>;
+                        export declare function timeoutToUndefined<T>(time: number, p: Promise<T>): Promise<T | undefined>;
+                        export declare function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>): Promise<T | undefined>;
+                        export declare function errorToWarning<T>(promise: Promise<T>): void;
+
+                    }
+
+                    declare module "socket-function/src/networking" {
+                        export declare const testTCPIsListening: (host: string, port: number) => Promise<boolean>;
+                        export declare const getExternalIP: {
+                            (): Promise<string>;
+                            reset(): void;
+                            set(newValue: Promise<string>): void;
+                        };
+                        export declare const getPublicIP: {
+                            (): Promise<string>;
+                            reset(): void;
+                            set(newValue: Promise<string>): void;
+                        };
+
+                    }
+
+                    declare module "socket-function/src/nodeCache" {
+                        import { CallFactory } from "./CallFactory";
+                        import { MaybePromise } from "./types";
+                        export declare function getNodeId(domain: string, port: number): string;
+                        /** @deprecated, call getBrowserUrlNode instead, which does important additional checks. */
+                        export declare function getNodeIdFromLocation(): string;
+                        /** A nodeId not available for reconnecting. */
+                        export declare function getClientNodeId(address: string): string;
+                        export declare function isClientNodeId(nodeId: string): boolean;
+                        /** Will always be available, even if getNodeIdLocation is not (as we don't always have the port,
+                         *      but we should always have an address).
+                         *  - Rarely used, as for logging you can just log the nodeId. ALSO, it isn't sufficient to reconnect, as the port is also needed!
+                         *  */
+                        export declare function getNodeIdIP(nodeId: string): string;
+                        export declare function getNodeIdLocation(nodeId: string): {
+                            address: string;
+                            port: number;
+                        } | undefined;
+                        export declare function getNodeIdDomain(nodeId: string): string;
+                        export declare function getNodeIdDomainMaybeUndefined(nodeId: string): string | undefined;
+                        export declare function registerNodeClient(callFactory: CallFactory): void;
+                        export declare function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory>;
+                        export declare function getCallFactory(nodeId: string): MaybePromise<CallFactory | undefined>;
+                        export declare function resetAllNodeCallFactories(): void;
+                        export declare function countOpenConnections(): number;
+
+                    }
+
+                    declare module "socket-function/src/nodeProxy" {
+                        import { FullCallType, SocketInternalInterface } from "../SocketFunctionTypes";
+                        type CallProxyType = {
+                            [nodeId: string]: SocketInternalInterface;
+                        };
+                        export declare const getCallObj: unique symbol;
+                        export declare function getCallProxy(id: string, callback: (callType: FullCallType) => Promise<unknown>): CallProxyType;
+                        export {};
+
+                    }
+
+                    declare module "socket-function/src/profiling/getOwnTime" {
+                        export type OwnTimeObj = {
+                            name: string;
+                            time: number;
+                            ownTime: number;
+                        };
+                        export type OwnTimeObjInternal = OwnTimeObj & {
+                            lastStartTime: number;
+                            firstStartTime: number;
+                        };
+                        export declare function getOpenTimesBase(): OwnTimeObjInternal[];
+                        export declare const measureOverheadTime: number;
+                        export declare function getOwnTime<T>(name: string, code: () => T, onTime: (obj: OwnTimeObj) => void): T;
+
+                    }
+
+                    declare module "socket-function/src/profiling/measure" {
+                        import { StatsValue } from "./stats";
+                        /** NOTE: Must be called BEFORE anything else is imported!
+                         *      NOTE: Measurements on on by default now, so this doesn't really need to be called...
+                        */
+                        export declare function enableMeasurements(): void;
+                        /** NOTE: Must be called BEFORE anything else is imported! */
+                        export declare function disableMeasurements(): void;
+                        export declare function measureFnc(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;
+                        export declare function nameFunction<T extends Function>(name: string, fnc: T): T;
+                        export declare function measureWrap<T extends (...args: any[]) => any>(fnc: T, name?: string): T;
+                        export declare function measureBlock<T extends (...args: any[]) => any>(fnc: T, name?: string): ReturnType<T>;
+                        /** NOTE: You should often call registerNodeMetadata for this as well. registerMeasureInfo
+                         *      is for logs, while registerNodeMetadata is for the overview page.
+                         */
+                        export declare function registerMeasureInfo(getInfo: () => string | undefined): void;
+                        /** IMPORTANT! Always finish the profile! If you don't, you will leak A LOT of memory
+                         *      (you leak all future measures, PER unfinished profile)!
+                         */
+                        export declare function startMeasure(): {
+                            finish: () => MeasureProfile;
+                        };
+                        export interface LogMeasureTableConfig {
+                            useTotalTime?: boolean;
+                            name?: string;
+                            setTitle?: boolean;
+                            thresholdInTable?: number;
+                            minTimeToLog?: number;
+                            mergeDepth?: number;
+                            maxTableEntries?: number;
+                            returnOnly?: boolean;
+                        }
+                        export interface FormattedMeasureTable {
+                            title: string;
+                            entries: {
+                                name: string;
+                                ownTime: number;
+                                fraction: number;
+                                equation: string;
+                            }[];
+                        }
+                        export declare function logMeasureTable(profile: MeasureProfile, config?: LogMeasureTableConfig): FormattedMeasureTable | undefined;
+                        export declare function measureCode<T>(code: () => Promise<T>, config?: LogMeasureTableConfig): Promise<T>;
+                        export declare function measureCodeSync<T>(code: () => T, config?: LogMeasureTableConfig): T;
+                        export interface MeasureProfile {
+                            startTime: number;
+                            endTime: number;
+                            entries: {
+                                [name: string]: ProfileEntry;
+                            };
+                        }
+                        export declare function createMeasureProfile(): MeasureProfile;
+                        export declare function addToMeasureProfile(base: MeasureProfile, other: MeasureProfile): void;
+                        interface ProfileEntry {
+                            name: string;
+                            ownTime: StatsValue;
+                            totalTime: StatsValue;
+                            stillOpenCount: number;
+                        }
+                        export {};
+
+                    }
+
+                    declare module "socket-function/src/profiling/stats" {
+                        export interface StatsValue {
+                            count: number;
+                            sum: number;
+                            sumSquares: number;
+                            logn7Value: number;
+                            logn7Count: number;
+                            logn6Value: number;
+                            logn6Count: number;
+                            logn5Value: number;
+                            logn5Count: number;
+                            logn4Value: number;
+                            logn4Count: number;
+                            logn3Value: number;
+                            logn3Count: number;
+                            logn2Value: number;
+                            logn2Count: number;
+                            logn1Value: number;
+                            logn1Count: number;
+                            log0Value: number;
+                            log0VCount: number;
+                            log1Value: number;
+                            log1VCount: number;
+                            log2Value: number;
+                            log2VCount: number;
+                            log3Value: number;
+                            log3VCount: number;
+                            log4Value: number;
+                            log4VCount: number;
+                            log5Value: number;
+                            log5VCount: number;
+                            log6Value: number;
+                            log6VCount: number;
+                            log7Value: number;
+                            log7VCount: number;
+                            log8Value: number;
+                            log8VCount: number;
+                            log9Value: number;
+                            log9VCount: number;
+                        }
+                        export declare function createStatsValue(): StatsValue;
+                        export declare function addToStatsValue(stats: StatsValue, value: number): void;
+                        export declare function addToStats(stats: StatsValue, other: StatsValue): void;
+                        export interface StatsTop {
+                            countFraction: number;
+                            valueFraction: number;
+                            count: number;
+                            value: number;
+                            topHeavy: boolean;
+                        }
+                        /** Identifies cases where the value is concentrated in few instances. This indicates most of the value (time)
+                         *      is not spent on the common case, but on an outlier. Which isn't a problem, it just means that the measurements
+                         *      should be more precise, to pull that heavy case out.
+                         */
+                        export declare function getStatsTop(stats: StatsValue): StatsTop;
+
+                    }
+
+                    declare module "socket-function/src/profiling/statsFormat" {
+                        import { StatsValue } from "./stats";
+                        export declare function percent(value: number): string;
+                        export declare function formatStats(stats: StatsValue, config?: {
+                            noColor?: boolean;
+                            noSum?: boolean;
+                            noSpaces?: boolean;
+                        }): string;
+
+                    }
+
+                    declare module "socket-function/src/profiling/tcpLagProxy" {
+                        export declare function tcpLagProxy(config: {
+                            localPort: number;
+                            remoteHost: string;
+                            remotePort: number;
+                            lag: number;
+                            networkWriteSize?: {
+                                value: number;
+                            };
+                            networkReadSize?: {
+                                value: number;
+                            };
+                            networkWritePackets?: {
+                                value: number;
+                            };
+                            networkReadPackets?: {
+                                value: number;
+                            };
+                        }): Promise<void>;
+
+                    }
+
+                    declare module "socket-function/src/promiseRace" {
+                        export declare class PromiseLessLeaky<T> extends Promise<T> {
+                            constructor(executor: ((resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) | undefined);
+                        }
+                        /** A promise race function which doesn't leak, unlike Promise.race
+
+                            See https://github.com/nodejs/node/issues/17469
+                            See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
+
+                         */
+                        export declare function promiseRace<T extends readonly unknown[] | []>(promises: T): Promise<Awaited<T[number]>>;
+
+                    }
+
+                    declare module "socket-function/src/runPromise" {
+                        export declare const runAsync: typeof runPromise;
+                        export declare function runPromise(command: string, config?: {
+                            cwd?: string;
+                            quiet?: boolean;
+                            nothrow?: boolean;
+                            detach?: boolean;
+                        }): Promise<string>;
+
+                    }
+
+                    declare module "socket-function/src/sniTest" {
+                        export {};
+
+                    }
+
+                    declare module "socket-function/src/storagePath" {
+                        export declare const getAppFolder: {
+                            (): string;
+                            reset(): void;
+                            set(newValue: string): void;
+                        };
+
+                    }
+
+                    declare module "socket-function/src/tlsParsing" {
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        export declare function parseTLSHello(buffer: Buffer): {
+                            extensions: {
+                                type: number;
+                                data: Buffer;
+                            }[];
+                            missingBytes: number;
+                        };
+                        export declare const SNIType = 0;
+                        export declare function parseSNIExtension(data: Buffer): string[];
+
+                    }
+
+                    declare module "socket-function/src/types" {
+                        export type MaybePromise<T> = T | Promise<T>;
+                        export type Args<T> = T extends (...args: infer V) => any ? V : never;
+                        export type AnyFunction = (...args: any) => any;
+                        export declare function canHaveChildren(value: unknown): value is {
+                            [key in PropertyKey]: unknown;
+                        };
+
+                    }
+
+                    declare module "socket-function/src/webSocketServer" {
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        /// <reference types="node" />
+                        import https from "https";
+                        import { Watchable } from "./misc";
+                        export type SocketServerConfig = (https.ServerOptions & {
+                            key: string | Buffer;
+                            cert: string | Buffer;
+                            port: number;
+                            /** You can also set `port: 0` if you don't care what port you want at all.  */
+                            useAvailablePortIfPortInUse?: boolean;
+                            public?: boolean;
+                            /** Tries forwarding ports (using UPnP), if we detect they aren't externally reachable.
+                             *      - This causes an extra request and delay during startup, so should only be used
+                             *          during development.
+                             *      - Ignored if public is false (in which case we mount on 127.0.0.1, so port forwarding
+                             *          wouldn't matter anyways).
+                            */
+                            autoForwardPort?: boolean;
+                            ip?: string;
+                            allowHostnames?: string[];
+                            allowHostnameFnc?: (hostname: string) => boolean;
+                            /** If the SNI matches this domain, we use a different key/cert.
+                             *      We remove subdomains until we find a match
+                             */
+                            SNICerts?: {
+                                [domain: string]: Watchable<https.ServerOptions>;
+                            };
+                        });
+                        export declare function startSocketServer(config: SocketServerConfig): Promise<string>;
+
+                    }
+
+                    declare module "socket-function/src/websocketFactory" {
+                        /// <reference types="node" />
+                        import tls from "tls";
+                        import { SenderInterface } from "./CallFactory";
+                        import type * as ws from "ws";
+                        export declare function getTLSSocket(webSocket: ws.WebSocket): tls.TLSSocket;
+                        /** NOTE: We create a factory, which embeds the key/cert information. Otherwise retries might use
+                         *      a different key/cert context.
+                         */
+                        export declare function createWebsocketFactory(): (nodeId: string) => SenderInterface;
+
+                    }
+
+                    declare module "socket-function/test" {
+                        export {};
+
+                    }
+
+                    declare module "socket-function/time/trueTimeShim" {
+                        export declare function getTrueTime(): number;
+                        export declare function getTrueTimeOffset(): number;
+                        export declare function waitForFirstTimeSync(): Promise<void> | undefined;
+                        export declare function shimDateNow(): void;
+                        export declare function getBrowserTime(): number;
+                        export declare function setGetTimeOffsetBase(base: () => Promise<number>): void;
+
+                    }
+
+                }
+
+                declare module "socket-function/mobx/UrlParam" {
+                    export declare class UrlParam<T> {
+                        private key;
+                        private defaultValue;
+                        constructor(key: string, defaultValue: T);
+                        valueSeqNum: {
+                            value: number;
+                        };
+                        get(): T;
+                        set(value: T): void;
+                        reset(): void;
+                        get value(): T;
+                        set value(value: T);
+                    }
+
+                }
+
+                declare module "socket-function/mobx/observer" {
+                    import type preact from "preact";
+                    import { Reaction } from "mobx";
+                    export declare function observer<T extends {
+                        new (...args: any[]): {
+                            render(): preact.ComponentChild;
+                            forceUpdate(callback?: () => void): void;
+                            componentWillUnmount?(): void;
+                        };
+                    }>(Constructor: T): {
+                        new (...args: any[]): {
+                            constructOrder: number;
+                            reaction: Reaction;
+                            componentWillUnmount(): void;
+                            render(): preact.ComponentChild;
+                            forceUpdate(callback?: () => void): void;
+                        };
+                        readonly name: string;
+                    } & T;
+
+                }
+
+                declare module "socket-function/mobx/promiseToObservable" {
+                    export interface InternalResult {
+                        result: {
+                            value: unknown;
+                        } | undefined;
+                    }
+                    export declare function promiseToObservable<T>(promise: Promise<T>, staleValue?: T): {
+                        value: T | undefined;
+                    };
+
+                }
+
+                declare module "socket-function/require/CSSShim" {
+                    /// <reference path="RequireController.d.ts" />
+                    export {};
+
+                }
+
+                declare module "socket-function/require/compileFlags" {
+                    /// <reference path="RequireController.d.ts" />
+                    /// <reference types="node" />
+                    /**
+                     *      Adds a global function setFlag(require, "typescript", flag) which sets a flag on the client
+                     *          - Ex, setFlag(require, "typescript", "allowclient") so allowclient = true on the typescript module.
+                     *          - Passing true as the fourth argument sets it recursively
+                     */
+                    export declare const forceModule = true;
+                    declare global {
+                    }
+                    export declare function setFlag(require: NodeRequire, request: string, flag: string, recursive?: boolean): void;
+
+                }
+
+                declare module "socket-function/require/extMapper" {
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    export declare function getExtContentType(ext: string): string;
+                    export declare function getContentTypeFromBuffer(buffer: Buffer): string | undefined;
+
+                }
+
+                declare module "socket-function/require/require" {
+                    /// <reference path="../index.d.ts" />
+                    declare global {
+                        var onProgressHandler: undefined | ((progress: {
+                            type: string;
+                            addValue: number;
+                            addMax: number;
+                        }) => void);
+                        var onErrorHandler: undefined | ((error: string) => void);
+                        var BOOT_TIME: number;
+                        var builtInModuleExports: {
+                            [key: string]: unknown;
+                        };
+                    }
+                    export declare function requireMain(): void;
+
+                }
+
+                declare module "socket-function/src/CallFactory" {
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    import { CallType } from "../SocketFunctionTypes";
+                    import * as ws from "ws";
+                    import * as tls from "tls";
+                    export interface CallFactory {
+                        nodeId: string;
+                        lastClosed: number;
+                        closedForever?: boolean;
+                        isConnected?: boolean;
+                        performCall(call: CallType): Promise<unknown>;
+                        onNextDisconnect(callback: () => void): void;
+                        connectionId: {
+                            nodeId: string;
+                        };
+                    }
+                    export interface SenderInterface {
+                        nodeId?: string;
+                        _socket?: tls.TLSSocket;
+                        send(data: string | Buffer): void;
+                        addEventListener(event: "open", listener: () => void): void;
+                        addEventListener(event: "close", listener: () => void): void;
+                        addEventListener(event: "error", listener: (err: {
+                            message: string;
+                        }) => void): void;
+                        addEventListener(event: "message", listener: (data: ws.RawData | ws.MessageEvent | string) => void): void;
+                        readyState: number;
+                        ping?(): void;
+                    }
+                    export declare function harvestFailedCallCount(): number;
+                    export declare function getPendingCallCount(): number;
+                    export declare function harvestCallTimes(): {
+                        start: number;
+                        end: number;
+                    }[];
+                    export declare function createCallFactory(webSocketBase: SenderInterface | undefined, nodeId: string, localNodeId?: string): Promise<CallFactory>;
+
+                }
+
+                declare module "socket-function/src/JSONLACKS/JSONLACKS" {
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    export interface JSONLACKS_ParseConfig {
+                        extended?: boolean;
+                        discardMissingReferences?: boolean;
+                    }
+                    export interface JSONLACKS_StringifyConfig {
+                        allowObjectMutation?: boolean;
+                    }
+                    interface HydrateState {
+                        references: Map<string, unknown>;
+                        visited: Set<unknown>;
+                    }
+                    export declare class JSONLACKS {
+                        static readonly LACKS_KEY = "__JSONLACKS__98cfb4a05fa34d828661cae15b8779ce__";
+                        /** If set to true parses non-quoted field names, comments, trailing commas, etc */
+                        static EXTENDED_PARSER: boolean;
+                        static IGNORE_MISSING_REFERENCES: boolean;
+                        static stringify(obj: unknown, config?: JSONLACKS_StringifyConfig): string;
+                        /** Is useful when serializing an array to a file with one object per line */
+                        static stringifyFile(obj: unknown[], config?: JSONLACKS_StringifyConfig): Promise<Buffer>;
+                        static stringifyFileSync(obj: unknown[], config?: JSONLACKS_StringifyConfig): Buffer;
+                        static parse<T>(text: string, config?: JSONLACKS_ParseConfig, hydrateState?: HydrateState): T;
+                        static parseLines<T>(buffer: Buffer, config?: JSONLACKS_ParseConfig): Promise<T[]>;
+                        private static escapeSpecialObjects;
+                        private static hydrateSpecialObjects;
+                    }
+                    export {};
+
+                }
+
+                declare module "socket-function/src/JSONLACKS/JSONLACKS.generated.js" {
+                    export function parse(text: string): unknown;
+                }
+
+                declare module "socket-function/src/args" {
+                    export declare const getArgs: {
+                        (): {
+                            [key: string]: string | undefined;
+                        };
+                        reset(): void;
+                        set(newValue: {
+                            [key: string]: string | undefined;
+                        }): void;
+                    };
+
+                }
+
+                declare module "socket-function/src/batching" {
+                    import { AnyFunction } from "./types";
+                    export type DelayType = (number | "afterio" | "immediate" | "afterpromises" | "paintLoop" | "afterPaint");
+                    export declare function delay(delayTime: DelayType, immediateShortDelays?: "immediateShortDelays"): Promise<void>;
+                    export declare function batchFunctionNone<Arg, Result = void>(config: unknown, fnc: (arg: Arg[]) => (Promise<Result> | Result)): (arg: Arg) => Promise<Result>;
+                    export declare function batchFunction<Arg, Result = void>(config: {
+                        delay: DelayType;
+                        /** Instead of immediately waiting delay, starts by waiting 0ms, and every call increments the delay factor
+                         *      by 1. Delay is `factor * (delay / throttleWindow)`. For every delay interval we have no calls, we decrease by
+                         *      no_calls/delay.
+                         *      - This essentially turns delay into a `calls per second` type indicator (ex, 10ms is 100 callers
+                         *          per second, 500ms is 2 calls, etc), which is accurate over delay * throttleWindow time.
+                         */
+                        throttleWindow?: number;
+                        name?: string;
+                        noMeasure?: boolean;
+                    }, fnc: (arg: Arg[]) => (Promise<Result> | Result)): (arg: Arg) => Promise<Result>;
+                    export declare function runInSerial<T extends (...args: any[]) => Promise<any>>(fnc: T): T;
+                    export declare function runInParallel<T extends (...args: any[]) => Promise<any>>(config: {
+                        parallelCount: number;
+                        callTimeout?: number;
+                    }, fnc: T): T;
+                    export declare function runInfinitePoll(delayTime: number, fnc: () => Promise<void> | void): void;
+                    export declare function runInfinitePollCallAtStart(delayTime: number, fnc: () => Promise<void> | void): Promise<void>;
+                    /** Disables polling, called on shutdown. Blocks until all pending poll loops finish */
+                    export declare function shutdownPolling(): Promise<void>;
+                    export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?: {
+                        maxRetries?: number;
+                        shouldRetry?: (message: string) => boolean;
+                        minDelay?: number;
+                        maxDelay?: number;
+                    }): T;
+
+                }
+
+                declare module "socket-function/src/caching" {
+                    import { AnyFunction, Args } from "./types";
+                    export declare function lazy<T>(factory: () => T): {
+                        (): T;
+                        reset(): void;
+                        set(newValue: T): void;
+                    };
+                    export declare function cacheEmptyArray<T>(array: T[]): T[];
+                    export declare function cache<Output, Key, Untracked extends unknown[]>(getValue: (key: Key, ...untracked: Untracked) => Output): {
+                        (key: Key, ...untracked: Untracked): Output;
+                        clear(key: Key): void;
+                        clearAll(): void;
+                        forceSet(key: Key, value: Output): void;
+                        getAllKeys(): Key[];
+                        get(key: Key): Output | undefined;
+                    };
+                    /** Makes a cache that limits the number of entries, allowing you to put arbitrary data in it
+                     *      without worrying about leaking memory
+                      */
+                    export declare function cacheLimited<Output, Key>(maxCount: number, getValue: (key: Key) => Output): {
+                        (input: Key): Output;
+                        forceSet(key: Key, value: Output): void;
+                        clearKey(key: Key): void;
+                        clear(): void;
+                    };
+                    export declare function cacheWeak<Output, Key extends object>(getValue: (key: Key) => Output): (key: Key) => Output;
+                    export declare function cacheList<Value>(getLength: () => number, getValue: (index: number) => Value): {
+                        (index: number): Value;
+                    };
+                    /** A cache half way between caching based on === and caching based on hash. Caches
+                     *      based on arrayEqual, which does === on all values in an array. Requires localized
+                     *      caching (as the comparisons don't scale with many candidates, unlike hashing),
+                     *      however works with non trival transformations (ex, resolving many persisted overrides
+                     *      to get a value), unlike cache().
+                     *  Also, limits itself, more of a performance optimization than memory optimization, as it scales
+                     *      very poorly with the number of candidates.
+                     *
+                     *  TIMING: About 6us with limit = 100, array size = 294, and the cache being full.
+                     */
+                    export declare function cacheArrayEqual<Input extends unknown[] | undefined, Output>(map: (arrays: Input) => Output, limit?: number): {
+                        (array: Input): Output;
+                        clear(array: Input): void;
+                        clearAll(): void;
+                    };
+                    /** Caches when arguments are ===. See cacheArrayEqual */
+                    export declare function cacheArgsEqual<Fnc extends AnyFunction>(fnc: Fnc, limit?: number): Fnc & {
+                        clear(...args: Args<Fnc>): void;
+                    };
+                    export declare function cacheJSONArgsEqual<Fnc extends AnyFunction>(fnc: Fnc, limit?: number): Fnc & {
+                        clear(...args: unknown[]): void;
+                        clearAll(): void;
+                    };
+                    export declare function cacheShallowConfigArgEqual<Fnc extends AnyFunction>(fnc: Fnc, limit?: number): Fnc & {
+                        clear(configObj: Args<Fnc>[0]): void;
+                        clearAll(): void;
+                    };
+                    export declare function externalCache<Key, Value>(): {
+                        get: (key: Key) => Value | undefined;
+                        set: (key: Key, value: Value) => void;
+                    };
+
+                }
+
+                declare module "socket-function/src/callHTTPHandler" {
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    import http from "http";
+                    import { CallType } from "../SocketFunctionTypes";
+                    export declare function setDefaultHTTPCall(call: CallType): void;
+                    export declare function getServerLocationFromRequest(request: http.IncomingMessage): {
+                        address: string;
+                        port: number;
+                    };
+                    export declare function getNodeIdsFromRequest(request: http.IncomingMessage): {
+                        nodeId: string;
+                        localNodeId: string;
+                    };
+                    export declare function getCurrentHTTPRequest(): http.IncomingMessage | undefined;
+                    export declare function httpCallHandler(request: http.IncomingMessage, response: http.ServerResponse): Promise<void>;
+                    declare const resultHeaders: unique symbol;
+                    type HTTPResultType = Buffer & {
+                        [resultHeaders]?: {
+                            [header: string]: string;
+                        };
+                    };
+                    export declare function setHTTPResultHeaders(result: HTTPResultType, headers: {
+                        [header: string]: string;
+                    }): HTTPResultType;
+                    export {};
+
+                }
+
+                declare module "socket-function/src/callManager" {
+                    /// <reference path="../hot/HotReloadController.d.ts" />
+                    import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
+                    export declare function getCallFlags(call: CallType): FunctionFlags | undefined;
+                    export declare function shouldCompressCall(call: CallType): boolean;
+                    export declare function performLocalCall(config: {
+                        call: FullCallType;
+                        caller: CallerContext;
+                    }): Promise<unknown>;
+                    export declare function isDataImmutable(call: CallType): boolean;
+                    export declare function registerClass(classGuid: string, controller: SocketExposedInterface, shape: SocketExposedShape, config?: {
+                        noFunctionMeasure?: boolean;
+                    }): void;
+                    export declare function exposeClass(exposedClass: SocketRegistered): void;
+                    export declare function registerGlobalHook(hook: SocketFunctionHook): void;
+                    export declare function unregisterGlobalHook(hook: SocketFunctionHook): void;
+                    export declare function registerGlobalClientHook(hook: SocketFunctionClientHook): void;
+                    export declare function unregisterGlobalClientHook(hook: SocketFunctionClientHook): void;
+                    export declare const runClientHooks: (callType: FullCallType, hooks: Exclude<SocketExposedShape[""], undefined>, connectionId: {
+                        nodeId: string;
+                    }) => Promise<ClientHookContext>;
+                    export declare const runServerHooks: (callType: FullCallType, caller: CallerContext, hooks: Exclude<SocketExposedShape[""], undefined>) => Promise<HookContext>;
+
+                }
+
+                declare module "socket-function/src/certStore" {
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    /** Must be populated before the server starts */
+                    export declare function trustCertificate(cert: string | Buffer): void;
+                    export declare function getTrustedCertificates(): string[];
+                    export declare function watchTrustedCertificates(callback: (certs: string[]) => void): () => boolean;
+
+                }
+
+                declare module "socket-function/src/corsCheck" {
+
+                }
+
+                declare module "socket-function/src/fixLargeNetworkCalls" {
+                    export declare function markArrayAsSplitable<T>(data: T[]): T[];
+                    export declare function isSplitableArray<T>(data: T): data is T & (unknown[]);
+
+                }
+
+                declare module "socket-function/src/formatting/colors" {
+                    export type HSL = {
+                        h: number;
+                        s: number;
+                        l: number;
+                    };
+                    export declare function hslText(color: HSL): string;
+                    export declare function hslToRGB(color: HSL): {
+                        r: number;
+                        g: number;
+                        b: number;
+                    };
+                    export declare function hslToHex(color: HSL): string;
+                    export declare function hslLightenGamma(hsl: HSL, fraction: number): {
+                        h: number;
+                        s: number;
+                        l: number;
+                    };
+                    export declare function hslLightenLinear(hsl: HSL, lightness: number): {
+                        h: number;
+                        s: number;
+                        l: number;
+                    };
+                    export declare function hslDarkenGamma(hsl: HSL, fraction: number): {
+                        h: number;
+                        s: number;
+                        l: number;
+                    };
+                    export declare function hslDarkenLinear(hsl: HSL, lightness: number): {
+                        h: number;
+                        s: number;
+                        l: number;
+                    };
+                    export declare function hslAddSaturate(hsl: HSL, saturation: number): {
+                        h: number;
+                        s: number;
+                        l: number;
+                    };
+                    export declare function hslSetSaturate(hsl: HSL, saturation: number): {
+                        h: number;
+                        s: number;
+                        l: number;
+                    };
+
+                }
+
+                declare module "socket-function/src/formatting/format" {
+                    export declare function formatTime(milliseconds: number | undefined, maxAbsoluteValue?: number): string;
+                    export declare function getTargetDecimals(maxAbsoluteValue: number, targetDigits: number): number;
+                    /** Adds decimal digits to reach digits. If the number is simply too large, it won't remove
+                     *      digits, there will instead just be no decimal point.
+                     */
+                    export declare function formatMaxDecimals(num: number, targetDigits: number, maxAbsoluteValue?: number, exactDecimals?: number): string;
+                    /** Actually formats any number, including decimals, by using K, M and B suffixes to get smaller values
+                     *      TODO: Support uK, uM and uB suffixes for very small numbers?
+                     *      <= 6 characters (<= 5 if positive)
+                     */
+                    export declare function formatNumber(count: number | undefined, maxAbsoluteValue?: number, noDecimal?: boolean, specialCurrency?: boolean): string;
+                    export declare function formatBinaryNumber(count: number | undefined, maxAbsoluteValue?: number, noDecimal?: boolean, specialCurrency?: boolean): string;
+                    /** YYYY/MM/DD HH:MM:SS PM/AM */
+                    export declare function formatDateTime(time: number): string;
+                    export declare function formatDateTimeDetailed(time: number): string;
+                    export declare function formatFileTimestampLocal(time: number): string;
+                    /** 2024 January 1, Monday, 12:53:02pm */
+                    export declare function formatNiceDateTime(time: number): string;
+                    /** 2024 January 1, Monday, 12:53:02pm (4 months ago)  */
+                    export declare function formatVeryNiceDateTime(time: number): string;
+                    /** YYYY/MM/DD */
+                    export declare function formatDate(time: number): string;
+                    /** <= 6 characters (<= 5 if positive) */
+                    export declare function formatPercent(value: number): string;
+
+                }
+
+                declare module "socket-function/src/formatting/logColors" {
+                    export declare const blue: (text: string) => string;
+                    export declare const red: (text: string) => string;
+                    export declare const green: (text: string) => string;
+                    export declare const yellow: (text: string) => string;
+                    export declare const white: (text: string) => string;
+                    export declare const gray: (text: string) => string;
+                    export declare const magenta: (text: string) => string;
+
+                }
+
+                declare module "socket-function/src/forwardPort" {
+                    export declare function forwardPort(config: {
+                        externalPort: number;
+                        internalPort: number;
+                        duration?: number;
+                    }): Promise<void>;
+
+                }
+
+                declare module "socket-function/src/https" {
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], method?: string, sendSessionCookies?: boolean, config?: {
+                        headers?: {
+                            [key: string]: string | undefined;
+                        };
+                        cancel?: Promise<void>;
+                    }): Promise<Buffer>;
 
-        declare module "socket-function/index" {
-            // Auto-generated file. Do not edit manually.
-            // Generated by: yarn generate-index-dts
+                }
 
-            declare module "socket-function/SetProcessVariables" {
-                export {};
+                declare module "socket-function/src/misc" {
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    import { MaybePromise } from "./types";
+                    export declare const timeInSecond = 1000;
+                    export declare const timeInMinute: number;
+                    export declare const timeInHour: number;
+                    export declare const timeInDay: number;
+                    export declare const timeInWeek: number;
+                    export declare const timeInYear: number;
+                    export type Watchable<T> = (callback: (value: T) => void) => MaybePromise<void>;
+                    export declare function convertErrorStackToError(error: string): Error;
+                    export declare function sha256Hash(buffer: Buffer | string): string;
+                    export declare function sha256HashBuffer(buffer: Buffer | string): Buffer;
+                    /** Async, but works both clientside and serverside. */
+                    export declare function sha256HashPromise(buffer: Buffer): Promise<any>;
+                    export declare function sha256BufferPromise(buffer: Buffer): Promise<Buffer>;
+                    export declare function arrayEqual(a: {
+                        [key: number]: unknown;
+                        length: number;
+                    }, b: {
+                        [key: number]: unknown;
+                        length: number;
+                    }): boolean;
+                    export declare function isNode(): boolean;
+                    export declare function isNodeTrue(): true;
+                    export declare function formatNumberSuffixed(count: number): string;
+                    export declare function list(count: number): number[];
+                    export declare function recursiveFreeze<T>(obj: T): T;
+                    export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
+                    export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
+                    export declare function isBufferType(obj: unknown): obj is BufferType;
+                    export declare function getKeys(obj: unknown): PropertyKey[];
+                    export declare function getStringKeys<T extends {}>(obj: T): ((keyof T) & string)[];
+                    export declare function keyBy<T, K>(arr: T[], getKey: (value: T) => K): Map<K, T>;
+                    export declare function keyByArray<T, K>(arr: T[], getKey: (value: T) => K): Map<K, T[]>;
+                    export declare function deepCloneJSON<T>(obj: T): T;
+                    export declare class PromiseObj<T = void> {
+                        promise: Promise<T>;
+                        value: {
+                            value?: T;
+                            error?: string;
+                        } | undefined;
+                        /** Resolve called does not mean the value is ready, as it may be resolved with a promise. */
+                        resolveCalled?: boolean;
+                        resolve: (value: T | Promise<T>) => void;
+                        reject: (error: any) => void;
+                        private baseResolve;
+                        private baseReject;
+                        constructor();
+                    }
+                    export declare function promiseObj<T = void>(): PromiseObj<T>;
+                    export declare function throttleFunction<Args extends any[]>(delay: number, fnc: (...args: Args) => MaybePromise<void>): (...args: Args) => Promise<void>;
+                    export declare function nextId(): string;
+                    export declare function arrayFromOrderObject<T>(obj: {
+                        [order: number]: T;
+                    }): T[];
+                    export declare function last<T>(arr: T[]): T | undefined;
+                    export type ObjectValues<T> = T[keyof T];
+                    export declare function entries<Obj extends {
+                        [key: string]: unknown;
+                    }>(obj: Obj): [keyof Obj, ObjectValues<Obj>][];
+                    export declare function keys<Obj extends {
+                        [key: string]: unknown;
+                    }>(obj: Obj): (keyof Obj)[];
+                    export declare function sort<T>(arr: T[], sortKey: (obj: T) => unknown): T[];
+                    export declare function getRootDomain(hostname: string): string;
+                    export declare class QueueLimited<T> {
+                        private readonly maxCount;
+                        private items;
+                        private nextIndex;
+                        constructor(maxCount: number);
+                        push(item: T): void;
+                        getAllUnordered(): T[];
+                        reset(): void;
+                        clear(): void;
+                        getOldest(): T | undefined;
+                    }
+                    export declare function binarySearchBasic<T, V>(array: T[], getVal: (val: T) => V, searchValue: V): number;
+                    export declare function binarySearchBasic2<T, V>(array: T[], getVal: (val: T) => V, searchValue: T): number;
+                    /**
+                     *  Searches indexes, allowing you to query structures that aren't arrays. To search an array, use:
+                     *      `binarySearchIndex(array.length, i => compare(array[i], searchValue))`
+                     *
+                     *      NOTE: If there are duplicates, returns the first match.
+                     *
+                     *      NOTE: If the value can't be found, returns the bitwise negation of the index where it should be inserted.
+                     *
+                     *      NOTE: With `if (index < 0) index = ~index;` you will get an index of the value >= the target value.
+                     */
+                    export declare function binarySearchIndex(listCount: number, compare: (lhsIndex: number) => number): number;
+                    export declare function compare(lhs: unknown, rhs: unknown): number;
+                    export declare function compareArray(lhs: unknown[], rhs: unknown[]): number;
+                    export declare function insertIntoSortedList<T>(list: T[], map: (val: T) => string | number, element: T): void;
+                    export declare function removeFromSortedList<T>(list: T[], map: (val: T) => string | number, searchValue: string | number): void;
+                    export declare function timeoutToError<T>(time: number, p: Promise<T>, err: () => Error): Promise<T>;
+                    export declare function timeoutToUndefined<T>(time: number, p: Promise<T>): Promise<T | undefined>;
+                    export declare function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>): Promise<T | undefined>;
+                    export declare function errorToWarning<T>(promise: Promise<T>): void;
 
-            }
+                }
 
-            declare module "socket-function/SocketFunction" {
-                /// <reference path="require/RequireController.d.ts" />
-                /// <reference types="node" />
-                /// <reference types="node" />
-                import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "./SocketFunctionTypes";
-                import { SocketServerConfig } from "./src/webSocketServer";
-                import { Args, MaybePromise } from "./src/types";
-                import "./SetProcessVariables";
-                type ExtractShape<ClassType, Shape> = {
-                    [key in keyof ClassType]: (key extends keyof Shape ? ClassType[key] extends SocketExposedInterface[""] ? ClassType[key] : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never : "Function is in shape, but not in class");
-                };
-                export declare class SocketFunction {
-                    static logMessages: boolean;
-                    static trackMessageSizes: {
-                        upload: ((size: number) => void)[];
-                        download: ((size: number) => void)[];
-                        callTimes: ((obj: {
-                            start: number;
-                            end: number;
-                        }) => void)[];
+                declare module "socket-function/src/networking" {
+                    export declare const testTCPIsListening: (host: string, port: number) => Promise<boolean>;
+                    export declare const getExternalIP: {
+                        (): Promise<string>;
+                        reset(): void;
+                        set(newValue: Promise<string>): void;
                     };
-                    static MAX_MESSAGE_SIZE: number;
-                    static HTTP_ETAG_CACHE: boolean;
-                    static silent: boolean;
-                    static HTTP_COMPRESS: boolean;
-                    static COEP: string;
-                    static COOP: string;
-                    static readonly WIRE_SERIALIZER: {
-                        serialize: (obj: unknown) => MaybePromise<Buffer[]>;
-                        deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
+                    export declare const getPublicIP: {
+                        (): Promise<string>;
+                        reset(): void;
+                        set(newValue: Promise<string>): void;
                     };
-                    static WIRE_WARN_TIME: number;
-                    private static onMountCallbacks;
-                    static exposedClasses: Set<string>;
-                    static callerContext: CallerContext | undefined;
-                    static getCaller(): CallerContext;
-                    static harvestFailedCallCount: () => number;
-                    static getPendingCallCount: () => number;
-                    static harvestCallTimes: () => {
-                        start: number;
-                        end: number;
-                    }[];
-                    static register<ClassInstance extends object, Shape extends SocketExposedShape<{
-                        [key in keyof ClassInstance]: (...args: any[]) => Promise<unknown>;
-                    }>, Statics>(classGuid: string, instance: ClassInstance | (() => ClassInstance), shapeFnc: () => Shape, defaultHooksFnc?: () => SocketExposedShape[""] & {
-                        onMount?: () => MaybePromise<void>;
-                    }, config?: {
-                        /** @noAutoExpose If true SocketFunction.expose(Controller) must be called explicitly. */
-                        noAutoExpose?: boolean;
-                        statics?: Statics;
-                        /** Skip timing functions calls. Useful if a lot of functions have wait time that
-                                is unrelated to processing, and therefore their timings won't be useful.
-                                - Also useful if our auto function wrapping code is breaking functionality,
-                                    such as if you have a singleton function which you compare with ===,
-                                    which will breaks because we replaced it with a wrapped measure function.
-                        */
-                        noFunctionMeasure?: boolean;
-                    }): SocketRegistered<ExtractShape<ClassInstance, Shape>> & Statics;
-                    private static socketCache;
-                    static rehydrateSocketCaller<Controller>(socketRegistered: SocketRegisterType<Controller>, shapeFnc?: () => SocketExposedShape): SocketRegistered<Controller>;
-                    private static callFromGuid;
-                    static onNextDisconnect(nodeId: string, callback: () => void): void;
-                    static getLastDisconnectTime(nodeId: string): number | undefined;
-                    static isNodeConnected(nodeId: string): boolean;
-                    /** NOTE: Only works if the nodeIs used is from SocketFunction.connect (we can't convert arbitrary nodeIds into urls,
-                     *      as we have no way of knowing how to contain a nodeId).
+
+                }
+
+                declare module "socket-function/src/nodeCache" {
+                    import { CallFactory } from "./CallFactory";
+                    import { MaybePromise } from "./types";
+                    export declare function getNodeId(domain: string, port: number): string;
+                    /** @deprecated, call getBrowserUrlNode instead, which does important additional checks. */
+                    export declare function getNodeIdFromLocation(): string;
+                    /** A nodeId not available for reconnecting. */
+                    export declare function getClientNodeId(address: string): string;
+                    export declare function isClientNodeId(nodeId: string): boolean;
+                    /** Will always be available, even if getNodeIdLocation is not (as we don't always have the port,
+                     *      but we should always have an address).
+                     *  - Rarely used, as for logging you can just log the nodeId. ALSO, it isn't sufficient to reconnect, as the port is also needed!
                      *  */
-                    static getHTTPCallLink(call: FullCallType): string;
-                    private static ignoreExposeCount;
-                    static ignoreExposeCalls<T>(code: () => Promise<T>): Promise<T>;
-                    /** Expose should be called before your mounting occurs. It mostly just exists to ensure you include the class type,
-                     *      so the class type's module construction runs, which should trigger register. Otherwise you would have
-                     *      to add additional imports to ensure the register call runs.
-                     */
-                    static expose(socketRegistered: SocketRegistered): void;
-                    static mountedNodeId: string;
-                    static isMounted(): boolean;
-                    static mountedIP: string;
-                    private static hasMounted;
-                    private static onMountCallback;
-                    static mountPromise: Promise<void>;
-                    static mount(config: SocketServerConfig): Promise<string>;
-                    /** Sets the default call when an http request is made, but no classGuid is set.
-                     *      NOTE: All other calls should be endpoint calls, even if those endpoints return a static file with an HTML content type.
-                     *          - However, to load new content, you should probably just use `require("./example.ts")`, which works on any files
-                     *              clientside that have also been required serverside (and whitelisted with module.allowclient = true,
-                     *              or with an `allowclient.flag` file in the directory or parent directory).
-                    */
-                    static setDefaultHTTPCall<Registered extends SocketRegistered, FunctionName extends keyof Registered["nodes"][""] & string>(registered: Registered, functionName: FunctionName, ...args: Args<Registered["nodes"][""][FunctionName]>): void;
-                    static connect(location: {
+                    export declare function getNodeIdIP(nodeId: string): string;
+                    export declare function getNodeIdLocation(nodeId: string): {
                         address: string;
                         port: number;
-                    }): string;
-                    static browserNodeId(): string;
-                    static getBrowserNodeId(): string;
-                    static addGlobalHook(hook: SocketFunctionHook): void;
-                    static addGlobalClientHook(hook: SocketFunctionClientHook): void;
-                }
-                declare global {
-                    var BOOTED_EDGE_NODE: {
-                        host: string;
                     } | undefined;
+                    export declare function getNodeIdDomain(nodeId: string): string;
+                    export declare function getNodeIdDomainMaybeUndefined(nodeId: string): string | undefined;
+                    export declare function registerNodeClient(callFactory: CallFactory): void;
+                    export declare function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory>;
+                    export declare function getCallFactory(nodeId: string): MaybePromise<CallFactory | undefined>;
+                    export declare function resetAllNodeCallFactories(): void;
+                    export declare function countOpenConnections(): number;
+
                 }
-                export declare function _setSocketContext<T>(caller: CallerContext, code: () => T): T;
-                export {};
 
-            }
+                declare module "socket-function/src/nodeProxy" {
+                    import { FullCallType, SocketInternalInterface } from "../SocketFunctionTypes";
+                    type CallProxyType = {
+                        [nodeId: string]: SocketInternalInterface;
+                    };
+                    export declare const getCallObj: unique symbol;
+                    export declare function getCallProxy(id: string, callback: (callType: FullCallType) => Promise<unknown>): CallProxyType;
+                    export {};
 
-            declare module "socket-function/SocketFunctionTypes" {
-                /// <reference path="require/RequireController.d.ts" />
-                import { getCallObj } from "./src/nodeProxy";
-                import { Args, MaybePromise } from "./src/types";
-                export declare const socket: unique symbol;
-                export type SocketExposedInterface = {
-                    [functionName: string]: (...args: any[]) => Promise<unknown>;
-                };
-                export type SocketInternalInterface = {
-                    [functionName: string]: {
-                        [getCallObj]: (...args: any[]) => FullCallType;
-                        (...args: any[]): Promise<unknown>;
+                }
+
+                declare module "socket-function/src/profiling/getOwnTime" {
+                    export type OwnTimeObj = {
+                        name: string;
+                        time: number;
+                        ownTime: number;
                     };
-                };
-                export type SocketExposedInterfaceClass = {
-                    new (): unknown;
-                    prototype: unknown;
-                };
-                export type FunctionFlags = {
-                    compress?: boolean;
-                    /** Indicates with the same input, we give the same output, forever,
-                     *      independent of code changes. This only works for data storage.
+                    export type OwnTimeObjInternal = OwnTimeObj & {
+                        lastStartTime: number;
+                        firstStartTime: number;
+                    };
+                    export declare function getOpenTimesBase(): OwnTimeObjInternal[];
+                    export declare const measureOverheadTime: number;
+                    export declare function getOwnTime<T>(name: string, code: () => T, onTime: (obj: OwnTimeObj) => void): T;
+
+                }
+
+                declare module "socket-function/src/profiling/measure" {
+                    import { StatsValue } from "./stats";
+                    /** NOTE: Must be called BEFORE anything else is imported!
+                     *      NOTE: Measurements on on by default now, so this doesn't really need to be called...
+                    */
+                    export declare function enableMeasurements(): void;
+                    /** NOTE: Must be called BEFORE anything else is imported! */
+                    export declare function disableMeasurements(): void;
+                    export declare function measureFnc(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;
+                    export declare function nameFunction<T extends Function>(name: string, fnc: T): T;
+                    export declare function measureWrap<T extends (...args: any[]) => any>(fnc: T, name?: string): T;
+                    export declare function measureBlock<T extends (...args: any[]) => any>(fnc: T, name?: string): ReturnType<T>;
+                    /** NOTE: You should often call registerNodeMetadata for this as well. registerMeasureInfo
+                     *      is for logs, while registerNodeMetadata is for the overview page.
                      */
-                    dataImmutable?: boolean;
-                    /** Allows overriding SocketFunction.MAX_MESSAGE_SIZE for responses from this function. */
-                    responseLimit?: number;
-                };
-                export type SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
-                    [functionName in keyof ExposedType]?: FunctionFlags & {
-                        hooks?: SocketFunctionHook[];
-                        clientHooks?: SocketFunctionClientHook[];
-                        noDefaultHooks?: boolean;
-                        /** BUG: I think this is broken if it is on the default hooks function? */
-                        noClientHooks?: boolean;
+                    export declare function registerMeasureInfo(getInfo: () => string | undefined): void;
+                    /** IMPORTANT! Always finish the profile! If you don't, you will leak A LOT of memory
+                     *      (you leak all future measures, PER unfinished profile)!
+                     */
+                    export declare function startMeasure(): {
+                        finish: () => MeasureProfile;
                     };
-                };
-                export type FncType = (...args: any[]) => Promise<unknown>;
-                export interface CallType<FncT extends FncType = FncType, FncName extends string = string> {
-                    classGuid: string;
-                    functionName: FncName;
-                    args: unknown[];
+                    export interface LogMeasureTableConfig {
+                        useTotalTime?: boolean;
+                        name?: string;
+                        setTitle?: boolean;
+                        thresholdInTable?: number;
+                        minTimeToLog?: number;
+                        mergeDepth?: number;
+                        maxTableEntries?: number;
+                        returnOnly?: boolean;
+                    }
+                    export interface FormattedMeasureTable {
+                        title: string;
+                        entries: {
+                            name: string;
+                            ownTime: number;
+                            fraction: number;
+                            equation: string;
+                        }[];
+                    }
+                    export declare function logMeasureTable(profile: MeasureProfile, config?: LogMeasureTableConfig): FormattedMeasureTable | undefined;
+                    export declare function measureCode<T>(code: () => Promise<T>, config?: LogMeasureTableConfig): Promise<T>;
+                    export declare function measureCodeSync<T>(code: () => T, config?: LogMeasureTableConfig): T;
+                    export interface MeasureProfile {
+                        startTime: number;
+                        endTime: number;
+                        entries: {
+                            [name: string]: ProfileEntry;
+                        };
+                    }
+                    export declare function createMeasureProfile(): MeasureProfile;
+                    export declare function addToMeasureProfile(base: MeasureProfile, other: MeasureProfile): void;
+                    interface ProfileEntry {
+                        name: string;
+                        ownTime: StatsValue;
+                        totalTime: StatsValue;
+                        stillOpenCount: number;
+                    }
+                    export {};
+
                 }
-                export interface FullCallType<FncT extends FncType = FncType, FncName extends string = string> extends CallType<FncT, FncName> {
-                    nodeId: string;
+
+                declare module "socket-function/src/profiling/stats" {
+                    export interface StatsValue {
+                        count: number;
+                        sum: number;
+                        sumSquares: number;
+                        logn7Value: number;
+                        logn7Count: number;
+                        logn6Value: number;
+                        logn6Count: number;
+                        logn5Value: number;
+                        logn5Count: number;
+                        logn4Value: number;
+                        logn4Count: number;
+                        logn3Value: number;
+                        logn3Count: number;
+                        logn2Value: number;
+                        logn2Count: number;
+                        logn1Value: number;
+                        logn1Count: number;
+                        log0Value: number;
+                        log0VCount: number;
+                        log1Value: number;
+                        log1VCount: number;
+                        log2Value: number;
+                        log2VCount: number;
+                        log3Value: number;
+                        log3VCount: number;
+                        log4Value: number;
+                        log4VCount: number;
+                        log5Value: number;
+                        log5VCount: number;
+                        log6Value: number;
+                        log6VCount: number;
+                        log7Value: number;
+                        log7VCount: number;
+                        log8Value: number;
+                        log8VCount: number;
+                        log9Value: number;
+                        log9VCount: number;
+                    }
+                    export declare function createStatsValue(): StatsValue;
+                    export declare function addToStatsValue(stats: StatsValue, value: number): void;
+                    export declare function addToStats(stats: StatsValue, other: StatsValue): void;
+                    export interface StatsTop {
+                        countFraction: number;
+                        valueFraction: number;
+                        count: number;
+                        value: number;
+                        topHeavy: boolean;
+                    }
+                    /** Identifies cases where the value is concentrated in few instances. This indicates most of the value (time)
+                     *      is not spent on the common case, but on an outlier. Which isn't a problem, it just means that the measurements
+                     *      should be more precise, to pull that heavy case out.
+                     */
+                    export declare function getStatsTop(stats: StatsValue): StatsTop;
+
                 }
-                export interface SocketFunctionHook {
-                    (config: HookContext): MaybePromise<void>;
-                    /** NOTE: This is useful when we need a clientside hook to set up state specifically for our serverside hook. */
-                    clientHook?: SocketFunctionClientHook;
+
+                declare module "socket-function/src/profiling/statsFormat" {
+                    import { StatsValue } from "./stats";
+                    export declare function percent(value: number): string;
+                    export declare function formatStats(stats: StatsValue, config?: {
+                        noColor?: boolean;
+                        noSum?: boolean;
+                        noSpaces?: boolean;
+                    }): string;
+
                 }
-                export type HookContext = {
-                    call: FullCallType;
-                    overrideResult?: unknown;
-                    onResult: ((result: unknown) => MaybePromise<void>)[];
-                };
-                export type ClientHookContext = {
-                    call: FullCallType;
-                    overrideResult?: unknown;
-                    onResult: ((result: unknown) => MaybePromise<void>)[];
-                    connectionId: {
-                        nodeId: string;
-                    };
-                };
-                export interface SocketFunctionClientHook {
-                    (config: ClientHookContext): MaybePromise<void>;
+
+                declare module "socket-function/src/profiling/tcpLagProxy" {
+                    export declare function tcpLagProxy(config: {
+                        localPort: number;
+                        remoteHost: string;
+                        remotePort: number;
+                        lag: number;
+                        networkWriteSize?: {
+                            value: number;
+                        };
+                        networkReadSize?: {
+                            value: number;
+                        };
+                        networkWritePackets?: {
+                            value: number;
+                        };
+                        networkReadPackets?: {
+                            value: number;
+                        };
+                    }): Promise<void>;
+
                 }
-                export interface SocketRegisterType<ExposedType = any> {
-                    _classGuid: string;
-                    _internalType: ExposedType;
+
+                declare module "socket-function/src/promiseRace" {
+                    export declare class PromiseLessLeaky<T> extends Promise<T> {
+                        constructor(executor: ((resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) | undefined);
+                    }
+                    /** A promise race function which doesn't leak, unlike Promise.race
+
+                        See https://github.com/nodejs/node/issues/17469
+                        See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
+
+                     */
+                    export declare function promiseRace<T extends readonly unknown[] | []>(promises: T): Promise<Awaited<T[number]>>;
+
                 }
-                export interface SocketRegistered<ExposedType = any> {
-                    nodes: {
-                        [nodeId: string]: {
-                            [functionName in keyof ExposedType]: ExposedType[functionName] & {
-                                [getCallObj]: (...args: Args<ExposedType[functionName]>) => FullCallType;
-                            };
-                        };
-                    };
-                    _classGuid: string;
-                    _internalType: ExposedType;
+
+                declare module "socket-function/src/runPromise" {
+                    export declare const runAsync: typeof runPromise;
+                    export declare function runPromise(command: string, config?: {
+                        cwd?: string;
+                        quiet?: boolean;
+                        nothrow?: boolean;
+                        detach?: boolean;
+                    }): Promise<string>;
+
                 }
-                export type ControllerPick<T extends SocketRegistered, K extends keyof T["_internalType"]> = (SocketRegistered<Pick<T["_internalType"], K>>);
-                export type CallerContext = Readonly<CallerContextBase>;
-                export type CallerContextBase = {
-                    nodeId: string;
-                    localNodeId: string;
-                };
 
-            }
+                declare module "socket-function/src/sniTest" {
+                    export {};
 
-            declare module "socket-function/hot/HotReloadController" {
-                /// <reference path="../../typenode/index.d.ts" />
-                /// <reference path="../require/RequireController.d.ts" />
-                /** Enables some hot reload functionality.
-                 *      - Triggers a refresh clientside
-                 *      - Triggers a reload server, for modules marked with `module.hotreload`
-                 */
-                export declare function watchFilesAndTriggerHotReloading(noAutomaticBrowserWatch?: boolean): void;
-                declare global {
-                    namespace NodeJS {
-                        interface Module {
-                            /** Causes us to hotreload the file. Applies both serverside and clientside.
-                             *      - If not set for any files clientside, we will refresh.
-                             *      - If not set for any files serverside, we will do nothing (and just leave old code running).
-                             */
-                            hotreload?: boolean;
-                            /** Overrides hotreload to disable hot reloading. Useful if you add "hotreload.flag" to a directory
-                             *      (which sets hotreload on all files in and under that directory), but want a specific file
-                             *      to not hotreload.
-                             *  - Also useful if you want files to hotreload clientside, but not serverside.
-                             */
-                            noserverhotreload?: boolean;
-                            watchAdditionalFiles?: string[];
-                        }
-                    }
-                    var isHotReloading: (() => boolean) | undefined;
                 }
-                export declare function isHotReloading(): boolean;
-                export declare function hotReloadingGuard(): true;
-                export declare function setExternalHotReloading(value: boolean): void;
-                export declare function onHotReload(callback: (modules: NodeJS.Module[]) => void): void;
-                export declare const HotReloadController: import("../SocketFunctionTypes").SocketRegistered<{
-                    watchFiles: () => Promise<void>;
-                    fileUpdated: (files: string[], changeTime: number) => Promise<void>;
-                }>;
 
-            }
+                declare module "socket-function/src/storagePath" {
+                    export declare const getAppFolder: {
+                        (): string;
+                        reset(): void;
+                        set(newValue: string): void;
+                    };
 
-            declare module "socket-function/index" {
-                /// <reference path="./node_modules/typenode/index.d.ts" />
+                }
 
-                export { };
+                declare module "socket-function/src/tlsParsing" {
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    export declare function parseTLSHello(buffer: Buffer): {
+                        extensions: {
+                            type: number;
+                            data: Buffer;
+                        }[];
+                        missingBytes: number;
+                    };
+                    export declare const SNIType = 0;
+                    export declare function parseSNIExtension(data: Buffer): string[];
 
-                declare global {
-                    namespace NodeJS {
-                        interface Module {
-                            original?: SerializedModule;
-                        }
-                    }
-                    interface SerializedModule {
-                        originalId: string;
-                        filename: string;
-                        // If a module is not allowed clientside it is likely requests will be empty,
-                        //  to save effort parsing requests for modules that only exist to give better
-                        //  error messages.
-                        requests: {
-                            // request => resolvedPath
-                            [request: string]: string;
+                }
+
+                declare module "socket-function/src/types" {
+                    export type MaybePromise<T> = T | Promise<T>;
+                    export type Args<T> = T extends (...args: infer V) => any ? V : never;
+                    export type AnyFunction = (...args: any) => any;
+                    export declare function canHaveChildren(value: unknown): value is {
+                        [key in PropertyKey]: unknown;
+                    };
+
+                }
+
+                declare module "socket-function/src/webSocketServer" {
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    /// <reference types="node" />
+                    import https from "https";
+                    import { Watchable } from "./misc";
+                    export type SocketServerConfig = (https.ServerOptions & {
+                        key: string | Buffer;
+                        cert: string | Buffer;
+                        port: number;
+                        /** You can also set `port: 0` if you don't care what port you want at all.  */
+                        useAvailablePortIfPortInUse?: boolean;
+                        public?: boolean;
+                        /** Tries forwarding ports (using UPnP), if we detect they aren't externally reachable.
+                         *      - This causes an extra request and delay during startup, so should only be used
+                         *          during development.
+                         *      - Ignored if public is false (in which case we mount on 127.0.0.1, so port forwarding
+                         *          wouldn't matter anyways).
+                        */
+                        autoForwardPort?: boolean;
+                        ip?: string;
+                        allowHostnames?: string[];
+                        allowHostnameFnc?: (hostname: string) => boolean;
+                        /** If the SNI matches this domain, we use a different key/cert.
+                         *      We remove subdomains until we find a match
+                         */
+                        SNICerts?: {
+                            [domain: string]: Watchable<https.ServerOptions>;
                         };
-                        asyncRequests: { [request: string]: true };
-                        // NOTE: IF !allowclient && !serveronly, it might just mean we didn't add allowclient
-                        //  to the module yet. BUT, if serveronly, then we know for sure we don't want it client.
-                        //  So the messages and behavior will be different.
-                        allowclient?: boolean;
-                        serveronly?: boolean;
-                        // Just for errors mostly
-                        alwayssend?: boolean;
+                    });
+                    export declare function startSocketServer(config: SocketServerConfig): Promise<string>;
 
-                        /** Only set if allowclient. */
-                        source?: string;
+                }
 
-                        seqNum: number;
+                declare module "socket-function/src/websocketFactory" {
+                    /// <reference types="node" />
+                    import tls from "tls";
+                    import { SenderInterface } from "./CallFactory";
+                    import type * as ws from "ws";
+                    export declare function getTLSSocket(webSocket: ws.WebSocket): tls.TLSSocket;
+                    /** NOTE: We create a factory, which embeds the key/cert information. Otherwise retries might use
+                     *      a different key/cert context.
+                     */
+                    export declare function createWebsocketFactory(): (nodeId: string) => SenderInterface;
 
-                        size?: number;
-                        version?: number;
+                }
 
-                        flags?: {
-                            [flag: string]: true;
-                        };
-                    }
+                declare module "socket-function/test" {
+                    export {};
 
                 }
+
+                declare module "socket-function/time/trueTimeShim" {
+                    export declare function getTrueTime(): number;
+                    export declare function getTrueTimeOffset(): number;
+                    export declare function waitForFirstTimeSync(): Promise<void> | undefined;
+                    export declare function shimDateNow(): void;
+                    export declare function getBrowserTime(): number;
+                    export declare function setGetTimeOffsetBase(base: () => Promise<number>): void;
+
+                }
+
             }
 
             declare module "socket-function/mobx/UrlParam" {
@@ -2730,7 +4846,7 @@ declare module "socket-function/index" {
     }
 
     declare module "socket-function/require/require" {
-        /// <reference path="../index.d.ts" />
+        /// <reference path="../src/src.d.ts" />
         declare global {
             var onProgressHandler: undefined | ((progress: {
                 type: string;
@@ -3472,6 +5588,52 @@ declare module "socket-function/index" {
 
     }
 
+    declare module "socket-function/src/src" {
+        /// <reference path="./node_modules/typenode/index.d.ts" />
+
+        export { };
+
+        declare global {
+            namespace NodeJS {
+                interface Module {
+                    original?: SerializedModule;
+                }
+            }
+            interface SerializedModule {
+                originalId: string;
+                filename: string;
+                // If a module is not allowed clientside it is likely requests will be empty,
+                //  to save effort parsing requests for modules that only exist to give better
+                //  error messages.
+                requests: {
+                    // request => resolvedPath
+                    [request: string]: string;
+                };
+                asyncRequests: { [request: string]: true };
+                // NOTE: IF !allowclient && !serveronly, it might just mean we didn't add allowclient
+                //  to the module yet. BUT, if serveronly, then we know for sure we don't want it client.
+                //  So the messages and behavior will be different.
+                allowclient?: boolean;
+                serveronly?: boolean;
+                // Just for errors mostly
+                alwayssend?: boolean;
+
+                /** Only set if allowclient. */
+                source?: string;
+
+                seqNum: number;
+
+                size?: number;
+                version?: number;
+
+                flags?: {
+                    [flag: string]: true;
+                };
+            }
+
+        }
+    }
+
     declare module "socket-function/src/storagePath" {
         export declare const getAppFolder: {
             (): string;
@@ -3651,7 +5813,7 @@ declare module "socket-function/require/extMapper" {
 }
 
 declare module "socket-function/require/require" {
-    /// <reference path="../index.d.ts" />
+    /// <reference path="../src/src.d.ts" />
     declare global {
         var onProgressHandler: undefined | ((progress: {
             type: string;
@@ -4393,6 +6555,52 @@ declare module "socket-function/src/sniTest" {
 
 }
 
+declare module "socket-function/src/src" {
+    /// <reference path="./node_modules/typenode/index.d.ts" />
+
+    export { };
+
+    declare global {
+        namespace NodeJS {
+            interface Module {
+                original?: SerializedModule;
+            }
+        }
+        interface SerializedModule {
+            originalId: string;
+            filename: string;
+            // If a module is not allowed clientside it is likely requests will be empty,
+            //  to save effort parsing requests for modules that only exist to give better
+            //  error messages.
+            requests: {
+                // request => resolvedPath
+                [request: string]: string;
+            };
+            asyncRequests: { [request: string]: true };
+            // NOTE: IF !allowclient && !serveronly, it might just mean we didn't add allowclient
+            //  to the module yet. BUT, if serveronly, then we know for sure we don't want it client.
+            //  So the messages and behavior will be different.
+            allowclient?: boolean;
+            serveronly?: boolean;
+            // Just for errors mostly
+            alwayssend?: boolean;
+
+            /** Only set if allowclient. */
+            source?: string;
+
+            seqNum: number;
+
+            size?: number;
+            version?: number;
+
+            flags?: {
+                [flag: string]: true;
+            };
+        }
+
+    }
+}
+
 declare module "socket-function/src/storagePath" {
     export declare const getAppFolder: {
         (): string;