@socket-mesh/core 1.0.0

package/README.md

@@ -0,0 +1,2 @@
+# auth-engine
+Auth module for SocketMesh

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./maps/index.js";
+export * from "./packet.js";
+export * from "./plugins/index.js";
+export * from "./request.js";
+export * from "./request-handler.js";
+export * from "./response.js";
+export * from "./socket.js";
+export * from "./socket-event.js";
+export * from "./socket-transport.js";
+export * from "./utils.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./maps/index.js";
+export * from "./packet.js";
+export * from "./plugins/index.js";
+export * from "./request.js";
+export * from "./request-handler.js";
+export * from "./response.js";
+export * from "./socket.js";
+export * from "./socket-event.js";
+export * from "./socket-transport.js";
+export * from "./utils.js";

package/dist/maps/handler-map.d.ts

@@ -0,0 +1,5 @@
+import { RequestHandler } from "../request-handler.js";
+import { SocketMap } from "./socket-map.js";
+export type HandlerMap<T extends SocketMap> = Partial<{
+    [K in keyof T['Incoming']]: RequestHandler<Parameters<T['Incoming'][K]>[0], ReturnType<T['Incoming'][K]>, T>;
+}>;

package/dist/maps/handler-map.js

@@ -0,0 +1 @@
+export {};

package/dist/maps/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./handler-map.js";
+export * from "./method-map.js";
+export * from "./socket-map.js";

package/dist/maps/index.js

@@ -0,0 +1,3 @@
+export * from "./handler-map.js";
+export * from "./method-map.js";
+export * from "./socket-map.js";

package/dist/maps/method-map.d.ts

@@ -0,0 +1,22 @@
+export type RemoveIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K];
+};
+export type MappedFunction = (...args: any) => any;
+export type PromiseReturnType<T> = T extends Promise<infer Return> ? Return : T;
+export type ServiceMap = {
+    [service: string]: MethodMap;
+};
+export type FunctionReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : never;
+export type MethodMap = {
+    [method: string]: MappedFunction;
+};
+export type PrivateMethodMap = {
+    [method: string]: MappedFunction;
+} & {
+    [method: `#${string}`]: MappedFunction;
+};
+export type PublicMethodMap = {
+    [method: string]: MappedFunction;
+} & {
+    [method: `#${string}`]: never;
+};

package/dist/maps/method-map.js

@@ -0,0 +1 @@
+export {};

package/dist/maps/socket-map.d.ts

@@ -0,0 +1,15 @@
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "./method-map.js";
+export interface SocketMap {
+    Incoming: MethodMap;
+    Service: ServiceMap;
+    Outgoing: PublicMethodMap;
+    PrivateOutgoing: PrivateMethodMap;
+    State: object;
+}
+export interface EmptySocketMap {
+    Incoming: {};
+    Service: {};
+    Outgoing: {};
+    PrivateOutgoing: {};
+    State: {};
+}

package/dist/maps/socket-map.js

@@ -0,0 +1 @@
+export {};

package/dist/packet.d.ts

@@ -0,0 +1,27 @@
+import { MethodMap, ServiceMap } from "./maps/method-map.js";
+import { SocketMap } from "./maps/socket-map.js";
+export type AnyPacket<T extends SocketMap> = ServicePacket<T['Service']> | MethodPacket<T['Incoming']>;
+export type ServicePacket<TServiceMap extends ServiceMap> = {
+    [TService in keyof TServiceMap]: {
+        [TMethod in keyof TServiceMap[TService]]: ServiceRequestPacket<TServiceMap, TService, TMethod>;
+    }[keyof TServiceMap[TService]];
+}[keyof TServiceMap];
+interface RequestPacket {
+    cid?: number;
+}
+export type MethodPacket<TMethodMap extends MethodMap> = {
+    [TMethod in keyof TMethodMap]: MethodRequestPacket<TMethodMap, TMethod>;
+}[keyof TMethodMap];
+export interface ServiceRequestPacket<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends RequestPacket {
+    service: TService;
+    method: TMethod;
+    ackTimeoutMs?: number | boolean;
+    data?: Parameters<TServiceMap[TService][TMethod]>[0];
+}
+export interface MethodRequestPacket<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends RequestPacket {
+    method: TMethod;
+    data: Parameters<TMethodMap[TMethod]>[0];
+    ackTimeoutMs?: number | boolean;
+}
+export declare function isRequestPacket<T extends SocketMap>(packet: unknown): packet is AnyPacket<T>;
+export {};

package/dist/packet.js

@@ -0,0 +1,3 @@
+export function isRequestPacket(packet) {
+    return (typeof packet === 'object') && 'method' in packet;
+}

package/dist/plugins/index.d.ts

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

package/dist/plugins/index.js

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

package/dist/plugins/plugin.d.ts

@@ -0,0 +1,50 @@
+import { EmptySocketMap, SocketMap } from "../maps/socket-map.js";
+import { AnyPacket } from "../packet.js";
+import { AnyRequest } from "../request.js";
+import { AnyResponse } from "../response.js";
+import { SocketTransport } from "../socket-transport.js";
+import { Socket, SocketStatus } from "../socket.js";
+import ws from "isomorphic-ws";
+import { HandlerMap } from "../maps/handler-map.js";
+export type PluginType = 'request' | 'response' | 'handshake';
+export interface PluginArgs<T extends SocketMap = EmptySocketMap> {
+    socket: Socket<T>;
+    transport: SocketTransport<T>;
+}
+export interface DisconnectedPluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
+    status: SocketStatus;
+    code: number;
+    reason?: string;
+}
+export interface MessagePluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
+    timestamp: Date;
+    packet: AnyPacket<T> | AnyResponse<T>;
+}
+export interface MessageRawPluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
+    timestamp: Date;
+    message: ws.RawData | string;
+    promise: Promise<void>;
+}
+export interface SendRequestPluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
+    requests: AnyRequest<T>[];
+    cont: (requests: AnyRequest<T>[]) => void;
+}
+export interface SendResponsePluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
+    responses: AnyResponse<T>[];
+    cont: (requests: AnyResponse<T>[]) => void;
+}
+export interface Plugin<T extends SocketMap = EmptySocketMap> {
+    type: string;
+    handlers?: HandlerMap<T>;
+    onAuthenticated?(options: PluginArgs<T>): void;
+    onClose?(options: PluginArgs<T>): void;
+    onDeauthenticate?(options: PluginArgs<T>): void;
+    onDisconnected?(options: DisconnectedPluginArgs<T>): void;
+    onEnd?(options: PluginArgs<T>): void;
+    onMessage?(options: MessagePluginArgs<T>): Promise<AnyPacket<T> | AnyResponse<T>>;
+    onMessageRaw?(options: MessageRawPluginArgs<T>): Promise<ws.RawData | string>;
+    onOpen?(options: PluginArgs<T>): void;
+    onReady?(options: PluginArgs<T>): void;
+    sendRequest?(options: SendRequestPluginArgs<T>): void;
+    sendResponse?(options: SendResponsePluginArgs<T>): void;
+}

package/dist/plugins/plugin.js

@@ -0,0 +1 @@
+export {};

package/dist/request-handler.d.ts

@@ -0,0 +1,24 @@
+import { Socket } from "./socket.js";
+import { SocketTransport } from "./socket-transport.js";
+import { EmptySocketMap, SocketMap } from "./maps/socket-map.js";
+export interface RequestHandlerArgsOptions<TOptions, T extends SocketMap, TSocket extends Socket<T> = Socket<T>, TTransport extends SocketTransport<T> = SocketTransport<T>> {
+    isRpc: boolean;
+    method: string;
+    socket: TSocket;
+    transport: TTransport;
+    timeoutMs?: number | boolean;
+    options?: TOptions;
+}
+export declare class RequestHandlerArgs<TOptions, T extends SocketMap = EmptySocketMap, TSocket extends Socket<T> = Socket<T>, TTransport extends SocketTransport<T> = SocketTransport<T>> {
+    isRpc: boolean;
+    method: string;
+    options: TOptions;
+    requestedAt: Date;
+    socket: TSocket;
+    timeoutMs?: number | boolean;
+    transport: TTransport;
+    constructor(options: RequestHandlerArgsOptions<TOptions, T, TSocket, TTransport>);
+    checkTimeout(timeLeftMs?: number): void;
+    getRemainingTimeMs(): number;
+}
+export type RequestHandler<TOptions, U, T extends SocketMap, TSocket extends Socket<T> = Socket<T>, TTransport extends SocketTransport<T> = SocketTransport<T>> = (args: RequestHandlerArgs<TOptions, T, TSocket, TTransport>) => Promise<U>;

package/dist/request-handler.js

@@ -0,0 +1,23 @@
+import { TimeoutError } from "@socket-mesh/errors";
+export class RequestHandlerArgs {
+    constructor(options) {
+        this.isRpc = options.isRpc;
+        this.method = options.method;
+        this.options = options.options;
+        this.requestedAt = new Date();
+        this.socket = options.socket;
+        this.transport = options.transport;
+        this.timeoutMs = options.timeoutMs;
+    }
+    checkTimeout(timeLeftMs = 0) {
+        if (typeof this.timeoutMs === 'number' && this.getRemainingTimeMs() <= timeLeftMs) {
+            throw new TimeoutError(`Method \'${this.method}\' timed out.`);
+        }
+    }
+    getRemainingTimeMs() {
+        if (typeof this.timeoutMs === 'number') {
+            return (this.requestedAt.valueOf() + this.timeoutMs) - new Date().valueOf();
+        }
+        return Infinity;
+    }
+}

package/dist/request.d.ts

@@ -0,0 +1,55 @@
+import { MethodMap, ServiceMap } from "./maps/method-map.js";
+import { SocketMap } from "./maps/socket-map.js";
+export type AnyRequest<T extends SocketMap> = ServiceRequest<T['Service']> | MethodRequest<T['PrivateOutgoing']> | MethodRequest<T['Outgoing']>;
+export declare function abortRequest<T extends SocketMap>(request: AnyRequest<T>, err: Error): void;
+export declare class RequestCollection<T extends SocketMap> {
+    private readonly _requests;
+    private readonly _callbacks;
+    constructor(requests: AnyRequest<T> | AnyRequest<T>[]);
+    get items(): ReadonlyArray<AnyRequest<T>>;
+    listen(cb: () => void): void;
+    isDone(): boolean;
+    [Symbol.iterator](): {
+        next(): {
+            value: AnyRequest<T>;
+            done: boolean;
+        } | {
+            done: boolean;
+            value?: undefined;
+        };
+    };
+}
+export type ServiceRequest<TServiceMap extends ServiceMap> = {
+    [TService in keyof TServiceMap]: {
+        [TMethod in keyof TServiceMap[TService]]: TransmitServiceRequest<TServiceMap, TService, TMethod> | InvokeServiceRequest<TServiceMap, TService, TMethod>;
+    }[keyof TServiceMap[TService]];
+}[keyof TServiceMap];
+export type MethodRequest<TMethodMap extends MethodMap> = {
+    [TMethod in keyof TMethodMap]: TransmitMethodRequest<TMethodMap, TMethod> | InvokeMethodRequest<TMethodMap, TMethod>;
+}[keyof TMethodMap];
+export interface Request {
+    promise: Promise<void>;
+    sentCallback?: (err?: Error) => void;
+}
+export interface TransmitServiceRequest<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends Request {
+    service: TService;
+    method: TMethod;
+    data?: Parameters<TServiceMap[TService][TMethod]>[0];
+}
+export interface TransmitMethodRequest<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends Request {
+    method: TMethod;
+    data?: Parameters<TMethodMap[TMethod]>[0];
+}
+export interface InvokeServiceRequest<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends TransmitServiceRequest<TServiceMap, TService, TMethod> {
+    cid: number;
+    ackTimeoutMs: number | false;
+    timeoutId?: NodeJS.Timeout;
+    callback: (err: Error, result?: TServiceMap[TService][TMethod]) => void | null;
+}
+export interface InvokeMethodRequest<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends TransmitMethodRequest<TMethodMap, TMethod> {
+    cid: number;
+    ackTimeoutMs: number | false;
+    timeoutId?: NodeJS.Timeout;
+    callback: (err: Error, result?: TMethodMap[TMethod]) => void | null;
+}
+export declare function isRequestDone<T extends SocketMap>(request: AnyRequest<T>): boolean;

package/dist/request.js

@@ -0,0 +1,56 @@
+import { toArray } from "./utils.js";
+export function abortRequest(request, err) {
+    if (request.sentCallback) {
+        request.sentCallback(err);
+    }
+    if ('callback' in request && request.callback) {
+        request.callback(err);
+    }
+}
+export class RequestCollection {
+    constructor(requests) {
+        this._requests = toArray(requests).filter(req => !isRequestDone(req));
+        this._callbacks = [];
+    }
+    get items() {
+        return this._requests;
+    }
+    listen(cb) {
+        for (const req of this._requests) {
+            this._callbacks.push(cb);
+            req.promise.finally(() => {
+                const i = this._requests.indexOf(req);
+                this._requests.splice(i, 1);
+                if (!this._requests.length) {
+                    for (const cb of this._callbacks) {
+                        cb();
+                    }
+                }
+            });
+        }
+    }
+    isDone() {
+        return this._requests.length === 0;
+    }
+    [Symbol.iterator]() {
+        const values = this._requests;
+        let index = 0;
+        return {
+            next() {
+                if (index < values.length) {
+                    const val = values[index];
+                    index++;
+                    return { value: val, done: false };
+                }
+                else
+                    return { done: true };
+            }
+        };
+    }
+}
+export function isRequestDone(request) {
+    if ('callback' in request) {
+        return (request.callback === null);
+    }
+    return !request.sentCallback;
+}

package/dist/response.d.ts

@@ -0,0 +1,22 @@
+import { MethodMap, ServiceMap } from "./maps/method-map.js";
+import { SocketMap } from "./maps/socket-map.js";
+export type AnyResponse<T extends SocketMap> = Response | ErrorResponse | ServiceDataResponse<T['Service']> | MethodDataResponse<T['PrivateOutgoing']> | MethodDataResponse<T['Outgoing']>;
+export declare function isResponsePacket<T extends SocketMap>(packet?: unknown): packet is AnyResponse<T>;
+export type ServiceDataResponse<TServiceMap extends ServiceMap> = {
+    [TService in keyof TServiceMap]: {
+        [TMethod in keyof TServiceMap[TService]]: DataResponse<ReturnType<TServiceMap[TService][TMethod]>>;
+    }[keyof TServiceMap[TService]];
+}[keyof TServiceMap];
+export type MethodDataResponse<TMethodMap extends MethodMap> = {
+    [TMethod in keyof TMethodMap]: DataResponse<ReturnType<TMethodMap[TMethod]>>;
+}[keyof TMethodMap];
+export interface Response {
+    rid: number;
+    timeoutAt?: Date;
+}
+export interface ErrorResponse extends Response {
+    error: Error;
+}
+export interface DataResponse<T> extends Response {
+    data: T;
+}

package/dist/response.js

@@ -0,0 +1,3 @@
+export function isResponsePacket(packet) {
+    return (typeof packet === 'object') && 'rid' in packet;
+}

package/dist/socket-event.d.ts

@@ -0,0 +1,76 @@
+import ws from "isomorphic-ws";
+import { ClientRequest, IncomingMessage } from "http";
+import { MethodPacket, ServicePacket } from "./packet.js";
+import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
+import { AnyResponse } from "./response.js";
+import { SocketMap } from "./maps/socket-map.js";
+export type SocketEvent<T extends SocketMap> = AuthStateChangeEvent | RemoveAuthTokenEvent | AuthenticateEvent | BadAuthTokenEvent | CloseEvent | ConnectEvent | ConnectingEvent | DeauthenticateEvent | DisconnectEvent | ErrorEvent | MessageEvent | PingEvent | PongEvent | RequestEvent<T> | ResponseEvent<T> | UnexpectedResponseEvent | UpgradeEvent;
+export type AuthStateChangeEvent = AuthenticatedChangeEvent | DeauthenticatedChangeEvent;
+export interface AuthenticatedChangeEvent {
+    isAuthenticated: true;
+    wasAuthenticated: boolean;
+    signedAuthToken: SignedAuthToken;
+    authToken: AuthToken;
+}
+export interface AuthenticateEvent {
+    wasSigned: boolean;
+    signedAuthToken: SignedAuthToken;
+    authToken: AuthToken;
+}
+export interface BadAuthTokenEvent {
+    error: Error;
+    signedAuthToken: SignedAuthToken;
+}
+export interface CloseEvent {
+    code: number;
+    reason?: string;
+}
+export interface ConnectEvent {
+    id: string;
+    isAuthenticated: boolean;
+    pingTimeoutMs: number;
+    authError?: Error;
+}
+export interface ConnectingEvent {
+}
+export interface DeauthenticateEvent {
+    signedAuthToken: SignedAuthToken;
+    authToken: AuthToken;
+}
+export interface DeauthenticatedChangeEvent {
+    isAuthenticated: false;
+    wasAuthenticated: true;
+}
+export interface DisconnectEvent {
+    code: number;
+    reason?: string;
+}
+export interface ErrorEvent {
+    error: Error;
+}
+export interface MessageEvent {
+    data: string | ws.RawData;
+    isBinary: boolean;
+}
+export interface PingEvent {
+    data: Buffer;
+}
+export interface PongEvent {
+    data: Buffer;
+}
+export interface RemoveAuthTokenEvent {
+    oldAuthToken: SignedAuthToken;
+}
+export interface RequestEvent<T extends SocketMap> {
+    request: ServicePacket<T['Service']> | MethodPacket<T['Incoming']>;
+}
+export interface ResponseEvent<T extends SocketMap> {
+    response: AnyResponse<T>;
+}
+export interface UnexpectedResponseEvent {
+    request: ClientRequest;
+    response: IncomingMessage;
+}
+export interface UpgradeEvent {
+    request: IncomingMessage;
+}

package/dist/socket-event.js

@@ -0,0 +1 @@
+export {};

package/dist/socket-transport.d.ts

@@ -0,0 +1,93 @@
+import { CodecEngine } from "@socket-mesh/formatter";
+import ws from "isomorphic-ws";
+import { Plugin } from "./plugins/plugin.js";
+import { AnyRequest, InvokeMethodRequest, InvokeServiceRequest, TransmitMethodRequest, TransmitServiceRequest } from "./request.js";
+import { AnyPacket } from "./packet.js";
+import { ClientRequest, IncomingMessage } from "http";
+import { FunctionReturnType, MethodMap, ServiceMap } from "./maps/method-map.js";
+import { AnyResponse } from "./response.js";
+import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
+import { Socket, SocketOptions, SocketStatus, StreamCleanupMode } from "./socket.js";
+import { SocketMap } from "./maps/socket-map.js";
+export type CallIdGenerator = () => number;
+export interface InvokeMethodOptions<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> {
+    method: TMethod;
+    ackTimeoutMs?: number | false;
+}
+export interface InvokeServiceOptions<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> {
+    service: TService;
+    method: TMethod;
+    ackTimeoutMs?: number | false;
+}
+export declare class SocketTransport<T extends SocketMap> {
+    private _socket;
+    private _webSocket;
+    private _inboundProcessedMessageCount;
+    private _inboundReceivedMessageCount;
+    private _outboundPreparedMessageCount;
+    private _outboundSentMessageCount;
+    private _isReady;
+    private _authToken?;
+    private _signedAuthToken?;
+    private readonly _callIdGenerator;
+    private readonly _callbackMap;
+    private readonly _handlers;
+    private _onUnhandledRequest;
+    readonly codecEngine: CodecEngine;
+    readonly plugins: Plugin<T>[];
+    streamCleanupMode: StreamCleanupMode;
+    id: string | null;
+    ackTimeoutMs: number;
+    private _pingTimeoutRef;
+    protected constructor(options?: SocketOptions<T>);
+    protected abortAllPendingCallbacksDueToBadConnection(status: SocketStatus): void;
+    get authToken(): AuthToken;
+    changeToUnauthenticatedState(): Promise<boolean>;
+    protected decode(data: string | ws.RawData): any;
+    disconnect(code?: number, reason?: string): void;
+    getBackpressure(): number;
+    getInboundBackpressure(): number;
+    getOutboundBackpressure(): number;
+    private handleInboudMessage;
+    protected onClose(code: number, reason?: Buffer | string): void;
+    protected onDisconnect(status: SocketStatus, code: number, reason?: string): void;
+    onError(error: Error): void;
+    protected onInvoke<TService extends keyof T['Service'], TServiceMethod extends keyof T['Service'][TService], TMethod extends keyof T['Outgoing'], TPrivateMethod extends keyof T['PrivateOutgoing']>(request: InvokeMethodRequest<T["Outgoing"], TMethod> | InvokeMethodRequest<T["PrivateOutgoing"], TPrivateMethod> | InvokeServiceRequest<T["Service"], TService, TServiceMethod>): void;
+    protected onMessage(data: ws.RawData, isBinary: boolean): void;
+    protected onOpen(): void;
+    protected onPing(data: Buffer): void;
+    protected onPong(data: Buffer): void;
+    protected onRequest(packet: AnyPacket<T>, timestamp: Date, pluginError?: Error): Promise<boolean>;
+    protected onResponse(response: AnyResponse<T>, pluginError?: Error): void;
+    protected onTransmit<TService extends keyof T['Service'], TServiceMethod extends keyof T['Service'][TService], TMethod extends keyof T['Outgoing']>(request: TransmitMethodRequest<T['Outgoing'], TMethod> | TransmitServiceRequest<T['Service'], TService, TServiceMethod>): void;
+    protected onUnexpectedResponse(request: ClientRequest, response: IncomingMessage): void;
+    protected onUnhandledRequest(packet: AnyPacket<T>): boolean;
+    protected onUpgrade(request: IncomingMessage): void;
+    ping(): Promise<void>;
+    protected resetPingTimeout(timeoutMs: number | false, code: number): void;
+    send(data: Buffer | string): Promise<void>;
+    protected sendRequest(requests: (AnyRequest<T>)[]): void;
+    protected sendRequest(index: number, requests: (AnyRequest<T>)[]): void;
+    protected sendResponse(responses: (AnyResponse<T>)[]): void;
+    protected sendResponse(index: number, responses: (AnyResponse<T>)[]): void;
+    setAuthorization(authToken: AuthToken): Promise<boolean>;
+    setAuthorization(signedAuthToken: SignedAuthToken, authToken?: AuthToken): Promise<boolean>;
+    setReadyStatus(pingTimeoutMs: number, authError?: Error): void;
+    get signedAuthToken(): SignedAuthToken;
+    get socket(): Socket<T>;
+    set socket(value: Socket<T>);
+    get status(): SocketStatus;
+    triggerAuthenticationEvents(wasSigned: boolean, wasAuthenticated: boolean): void;
+    transmit<TMethod extends keyof T['Outgoing']>(method: TMethod, arg?: Parameters<T['Outgoing'][TMethod]>[0]): Promise<void>;
+    transmit<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: [TService, TMethod], arg?: Parameters<T['Service'][TService][TMethod]>[0]): Promise<void>;
+    transmit<TMethod extends keyof T['PrivateOutgoing']>(method: TMethod, arg?: Parameters<T['PrivateOutgoing'][TMethod]>[0]): Promise<void>;
+    invoke<TMethod extends keyof T['Outgoing']>(method: TMethod, arg?: Parameters<T['Outgoing'][TMethod]>[0]): [Promise<FunctionReturnType<T['Outgoing'][TMethod]>>, () => void];
+    invoke<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: [TService, TMethod, (number | false)?], arg?: Parameters<T['Service'][TService][TMethod]>[0]): [Promise<FunctionReturnType<T['Service'][TService][TMethod]>>, () => void];
+    invoke<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: InvokeServiceOptions<T['Service'], TService, TMethod>, arg?: Parameters<T['Service'][TService][TMethod]>[0]): [Promise<FunctionReturnType<T['Service'][TService][TMethod]>>, () => void];
+    invoke<TMethod extends keyof T['Outgoing']>(options: InvokeMethodOptions<T['Outgoing'], TMethod>, arg?: Parameters<T['Outgoing'][TMethod]>[0]): [Promise<FunctionReturnType<T['Outgoing'][TMethod]>>, () => void];
+    invoke<TMethod extends keyof T['PrivateOutgoing']>(method: TMethod, arg: Parameters<T['PrivateOutgoing'][TMethod]>[0]): [Promise<FunctionReturnType<T['PrivateOutgoing'][TMethod]>>, () => void];
+    invoke<TMethod extends keyof T['PrivateOutgoing']>(options: InvokeMethodOptions<T['PrivateOutgoing'], TMethod>, arg?: Parameters<T['PrivateOutgoing'][TMethod]>[0]): [Promise<FunctionReturnType<T['PrivateOutgoing'][TMethod]>>, () => void];
+    get url(): string;
+    protected get webSocket(): ws.WebSocket;
+    protected set webSocket(value: ws.WebSocket | null);
+}