@socket-mesh/client 18.1.4 → 18.1.6

package/dist/client-auth-engine.d.ts

@@ -1,22 +1,22 @@
-import { SignedAuthToken } from "@socket-mesh/auth";
+import { SignedAuthToken } from '@socket-mesh/auth';
 export interface ClientAuthEngine {
+    loadToken(): Promise<null | SignedAuthToken>;
+    removeToken(): Promise<null | SignedAuthToken>;
     saveToken(token: SignedAuthToken, options?: {
         [key: string]: any;
     }): Promise<SignedAuthToken>;
-    removeToken(): Promise<SignedAuthToken>;
-    loadToken(): Promise<SignedAuthToken | null>;
 }
-export declare function isAuthEngine(auth: ClientAuthEngine | LocalStorageAuthEngineOptions): auth is ClientAuthEngine;
 export interface LocalStorageAuthEngineOptions {
     authTokenName?: string;
 }
+export declare function isAuthEngine(auth?: ClientAuthEngine | LocalStorageAuthEngineOptions | null): auth is ClientAuthEngine;
 export declare class LocalStorageAuthEngine implements ClientAuthEngine {
     private readonly _authTokenName;
     private readonly _internalStorage;
     readonly isLocalStorageEnabled: boolean;
     constructor({ authTokenName }?: LocalStorageAuthEngineOptions);
-    private _checkLocalStorageEnabled;
+    private checkLocalStorageEnabled;
+    loadToken(): Promise<null | SignedAuthToken>;
+    removeToken(): Promise<null | SignedAuthToken>;
     saveToken(token: string): Promise<SignedAuthToken>;
-    removeToken(): Promise<SignedAuthToken>;
-    loadToken(): Promise<SignedAuthToken>;
 }

package/dist/client-auth-engine.js

@@ -1,18 +1,21 @@
 export function isAuthEngine(auth) {
-    return (typeof auth === 'object' && 'saveToken' in auth && 'removeToken' in auth && 'loadToken' in auth);
+    return (!!auth && typeof auth === 'object' && 'saveToken' in auth && 'removeToken' in auth && 'loadToken' in auth);
 }
 export class LocalStorageAuthEngine {
+    _authTokenName;
+    _internalStorage;
+    isLocalStorageEnabled;
     constructor({ authTokenName } = {}) {
         this._internalStorage = {};
-        this.isLocalStorageEnabled = this._checkLocalStorageEnabled();
+        this.isLocalStorageEnabled = this.checkLocalStorageEnabled();
         this._authTokenName = authTokenName ?? 'socketmesh.authToken';
     }
-    _checkLocalStorageEnabled() {
+    checkLocalStorageEnabled() {
         let err;
         try {
             // Safari, in Private Browsing Mode, looks like it supports localStorage but all calls to setItem
             // throw QuotaExceededError. We're going to detect this and avoid hard to debug edge cases.
-            localStorage.setItem('__localStorageTest', "1");
+            localStorage.setItem('__localStorageTest', '1');
             localStorage.removeItem('__localStorageTest');
         }
         catch (e) {
@@ -20,17 +23,18 @@ export class LocalStorageAuthEngine {
         }
         return !err;
     }
-    async saveToken(token) {
+    async loadToken() {
+        let token;
         if (this.isLocalStorageEnabled) {
-            localStorage.setItem(this._authTokenName, token);
+            token = localStorage.getItem(this._authTokenName);
         }
         else {
-            this._internalStorage[this._authTokenName] = token;
+            token = this._internalStorage[this._authTokenName] || null;
         }
         return token;
     }
     async removeToken() {
-        let loadPromise = this.loadToken();
+        const loadPromise = this.loadToken();
         if (this.isLocalStorageEnabled) {
             localStorage.removeItem(this._authTokenName);
         }
@@ -39,13 +43,12 @@ export class LocalStorageAuthEngine {
         }
         return loadPromise;
     }
-    async loadToken() {
-        let token;
+    async saveToken(token) {
         if (this.isLocalStorageEnabled) {
-            token = localStorage.getItem(this._authTokenName);
+            localStorage.setItem(this._authTokenName, token);
         }
         else {
-            token = this._internalStorage[this._authTokenName] || null;
+            this._internalStorage[this._authTokenName] = token;
         }
         return token;
     }

package/dist/client-channels.d.ts

@@ -1,20 +1,20 @@
-import { ChannelDetails, Channels, ChannelsOptions } from "@socket-mesh/channels";
-import { ClientTransport } from "./client-transport.js";
-import { ClientMap } from "./maps/client-map.js";
+import { ChannelDetails, ChannelMap, Channels, ChannelsOptions } from '@socket-mesh/channels';
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from '@socket-mesh/core';
+import { ClientTransport } from './client-transport.js';
 export interface ClientChannelsOptions extends ChannelsOptions {
     autoSubscribeOnConnect?: boolean;
 }
-export declare class ClientChannels<T extends ClientMap> extends Channels<T['Channel']> {
-    autoSubscribeOnConnect: boolean;
-    protected readonly _transport: ClientTransport<T>;
+export declare class ClientChannels<TChannel extends ChannelMap, TIncoming extends MethodMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TState extends object> extends Channels<TChannel> {
     protected _preparingPendingSubscriptions: boolean;
-    constructor(transport: ClientTransport<T>, options?: ClientChannelsOptions);
+    protected readonly _transport: ClientTransport<TIncoming, TService, TOutgoing, TPrivateOutgoing, TState>;
+    autoSubscribeOnConnect: boolean;
+    constructor(transport: ClientTransport<TIncoming, TService, TOutgoing, TPrivateOutgoing, TState>, options?: ClientChannelsOptions);
+    invokePublish<U extends keyof TChannel & string>(channelName: keyof TChannel & string, data: TChannel[U]): Promise<void>;
+    private processPendingSubscriptions;
     private suspendSubscriptions;
+    transmitPublish<U extends keyof TChannel & string>(channelName: U, data: TChannel[U]): Promise<void>;
+    private triggerChannelSubscribeFail;
     protected trySubscribe(channel: ChannelDetails): void;
-    private processPendingSubscriptions;
-    unsubscribe(channelName: keyof T['Channel'] & string): void;
     protected tryUnsubscribe(channel: ChannelDetails): void;
-    private triggerChannelSubscribeFail;
-    transmitPublish<U extends keyof T['Channel'] & string>(channelName: U, data: T['Channel'][U]): Promise<void>;
-    invokePublish<U extends keyof T['Channel'] & string>(channelName: keyof T['Channel'] & string, data: T['Channel'][U]): Promise<void>;
+    unsubscribe(channelName: keyof TChannel & string): void;
 }

package/dist/client-channels.js

@@ -1,5 +1,8 @@
-import { Channels } from "@socket-mesh/channels";
+import { Channels } from '@socket-mesh/channels';
 export class ClientChannels extends Channels {
+    _preparingPendingSubscriptions;
+    _transport;
+    autoSubscribeOnConnect;
     constructor(transport, options) {
         if (!options) {
             options = {};
@@ -9,20 +12,51 @@ export class ClientChannels extends Channels {
         this._transport = transport;
         this._preparingPendingSubscriptions = false;
         this._transport.plugins.push({
-            type: 'channels',
             onAuthenticated: () => {
                 if (!this._preparingPendingSubscriptions) {
                     this.processPendingSubscriptions();
                 }
             },
+            onClose: () => {
+                this.suspendSubscriptions();
+            },
             onReady: () => {
                 if (this.autoSubscribeOnConnect) {
                     this.processPendingSubscriptions();
                 }
             },
-            onClose: () => {
-                this.suspendSubscriptions();
-            },
+            type: 'channels'
+        });
+    }
+    invokePublish(channelName, data) {
+        const pubData = {
+            channel: this.decorateChannelName(channelName),
+            data
+        };
+        return this._transport.invoke('#publish', pubData)[0];
+    }
+    processPendingSubscriptions() {
+        this._preparingPendingSubscriptions = false;
+        const pendingChannels = [];
+        Object.keys(this._channelMap).forEach((channelName) => {
+            const channel = this._channelMap[channelName];
+            if (channel.state === 'pending') {
+                pendingChannels.push(channel);
+            }
+        });
+        pendingChannels.sort((a, b) => {
+            const ap = a.options.priority || 0;
+            const bp = b.options.priority || 0;
+            if (ap > bp) {
+                return -1;
+            }
+            if (ap < bp) {
+                return 1;
+            }
+            return 0;
+        });
+        pendingChannels.forEach((channel) => {
+            this.trySubscribe(channel);
         });
     }
     suspendSubscriptions() {
@@ -30,13 +64,37 @@ export class ClientChannels extends Channels {
             this.triggerChannelUnsubscribe(this._channelMap[channel], true);
         }
     }
+    transmitPublish(channelName, data) {
+        const pubData = {
+            channel: this.decorateChannelName(channelName),
+            data
+        };
+        return this._transport.transmit('#publish', pubData);
+    }
+    triggerChannelSubscribeFail(err, channel, options) {
+        const hasAuthRequirements = !channel.options.waitForAuth || !!this._transport.signedAuthToken;
+        const hasChannel = !!this._channelMap[channel.name];
+        if (hasChannel && hasAuthRequirements) {
+            delete this._channelMap[channel.name];
+            this._channelEventDemux.write(`${channel.name}/subscribeFail`, {
+                channel: channel.name,
+                error: err,
+                options
+            });
+            this.emit('subscribeFail', {
+                channel: channel.name,
+                error: err,
+                options
+            });
+        }
+    }
     trySubscribe(channel) {
-        const meetsAuthRequirements = !channel.options.waitForAuth || !!this._transport.signedAuthToken;
+        const hasAuthRequirements = !channel.options.waitForAuth || !!this._transport.signedAuthToken;
         // We can only ever have one pending subscribe action at any given time on a channel
-        if (this._transport.status === 'ready' &&
-            !this._preparingPendingSubscriptions &&
-            !channel.subscribePromise &&
-            meetsAuthRequirements) {
+        if (this._transport.status === 'ready'
+            && !this._preparingPendingSubscriptions
+            && !channel.subscribePromise
+            && hasAuthRequirements) {
             const subscriptionOptions = {};
             if (channel.options.waitForAuth) {
                 subscriptionOptions.waitForAuth = true;
@@ -44,7 +102,7 @@ export class ClientChannels extends Channels {
             if (channel.options.data) {
                 subscriptionOptions.data = channel.options.data;
             }
-            [channel.subscribePromise, channel.subscribeAbort] = this._transport.invoke({ method: '#subscribe', ackTimeoutMs: false }, {
+            [channel.subscribePromise, channel.subscribeAbort] = this._transport.invoke({ ackTimeoutMs: false, method: '#subscribe' }, {
                 channel: this.decorateChannelName(channel.name),
                 ...subscriptionOptions
             });
@@ -52,7 +110,7 @@ export class ClientChannels extends Channels {
                 delete channel.subscribePromise;
                 delete channel.subscribeAbort;
                 this.triggerChannelSubscribe(channel, subscriptionOptions);
-            }).catch(err => {
+            }).catch((err) => {
                 if (err.name === 'BadConnectionError') {
                     // In case of a failed connection, keep the subscription
                     // as pending; it will try again on reconnect.
@@ -70,36 +128,6 @@ export class ClientChannels extends Channels {
             });
         }
     }
-    processPendingSubscriptions() {
-        this._preparingPendingSubscriptions = false;
-        const pendingChannels = [];
-        Object.keys(this._channelMap).forEach((channelName) => {
-            const channel = this._channelMap[channelName];
-            if (channel.state === 'pending') {
-                pendingChannels.push(channel);
-            }
-        });
-        pendingChannels.sort((a, b) => {
-            const ap = a.options.priority || 0;
-            const bp = b.options.priority || 0;
-            if (ap > bp) {
-                return -1;
-            }
-            if (ap < bp) {
-                return 1;
-            }
-            return 0;
-        });
-        pendingChannels.forEach((channel) => {
-            this.trySubscribe(channel);
-        });
-    }
-    unsubscribe(channelName) {
-        const channel = this._channelMap[channelName];
-        if (channel) {
-            this.tryUnsubscribe(channel);
-        }
-    }
     tryUnsubscribe(channel) {
         this.triggerChannelUnsubscribe(channel);
         if (this._transport.status === 'ready') {
@@ -112,38 +140,13 @@ export class ClientChannels extends Channels {
             // the operation on the server side.
             this._transport
                 .transmit('#unsubscribe', decoratedChannelName)
-                .catch(err => { });
+                .catch((err) => { });
         }
     }
-    triggerChannelSubscribeFail(err, channel, options) {
-        const meetsAuthRequirements = !channel.options.waitForAuth || !!this._transport.signedAuthToken;
-        const hasChannel = !!this._channelMap[channel.name];
-        if (hasChannel && meetsAuthRequirements) {
-            delete this._channelMap[channel.name];
-            this._channelEventDemux.write(`${channel.name}/subscribeFail`, {
-                channel: channel.name,
-                error: err,
-                options
-            });
-            this.emit('subscribeFail', {
-                error: err,
-                channel: channel.name,
-                options
-            });
+    unsubscribe(channelName) {
+        const channel = this._channelMap[channelName];
+        if (channel) {
+            this.tryUnsubscribe(channel);
         }
     }
-    transmitPublish(channelName, data) {
-        const pubData = {
-            channel: this.decorateChannelName(channelName),
-            data
-        };
-        return this._transport.transmit('#publish', pubData);
-    }
-    invokePublish(channelName, data) {
-        const pubData = {
-            channel: this.decorateChannelName(channelName),
-            data
-        };
-        return this._transport.invoke('#publish', pubData)[0];
-    }
 }

package/dist/client-socket-options.d.ts

@@ -1,24 +1,27 @@
-import ws from "isomorphic-ws";
-import { SocketOptions } from "@socket-mesh/core";
-import { ClientAuthEngine, LocalStorageAuthEngineOptions } from "./client-auth-engine.js";
-import { SocketMapFromClient } from "./maps/socket-map.js";
-import { ClientMap } from "./maps/client-map.js";
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, SocketOptions } from '@socket-mesh/core';
+import ws from 'isomorphic-ws';
+import { ClientAuthEngine, LocalStorageAuthEngineOptions } from './client-auth-engine.js';
+import { ClientPrivateMap } from './maps/client-map.js';
+import { ServerPrivateMap } from './maps/server-map.js';
 export interface AutoReconnectOptions {
     initialDelay: number;
-    randomness: number;
-    multiplier: number;
     maxDelayMs: number;
+    multiplier: number;
+    randomness: number;
+}
+export interface ClientSocketOptions<TOutgoing extends PublicMethodMap = {}, TService extends ServiceMap = {}, TIncoming extends MethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TState extends object = {}> extends SocketOptions<TIncoming & ClientPrivateMap, TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService, TState> {
+    address: string | URL;
+    authEngine?: ClientAuthEngine | LocalStorageAuthEngineOptions | null;
+    autoConnect?: boolean;
+    autoReconnect?: boolean | Partial<AutoReconnectOptions>;
+    autoSubscribeOnConnect?: boolean;
+    channelPrefix?: string;
+    connectTimeoutMs?: number;
+    wsOptions?: ws.ClientOptions;
 }
 export interface ConnectOptions {
     address?: string | URL;
     connectTimeoutMs?: number;
     wsOptions?: ws.ClientOptions;
 }
-export interface ClientSocketOptions<T extends ClientMap> extends SocketOptions<SocketMapFromClient<T>>, ConnectOptions {
-    autoConnect?: boolean;
-    authEngine?: ClientAuthEngine | LocalStorageAuthEngineOptions | null;
-    autoReconnect?: Partial<AutoReconnectOptions> | boolean;
-    autoSubscribeOnConnect?: boolean;
-    channelPrefix?: string;
-}
-export declare function parseClientOptions<T extends ClientMap>(options: ClientSocketOptions<T> | string | URL): ClientSocketOptions<T>;
+export declare function parseClientOptions<TIncoming extends MethodMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TState extends object>(options: ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState> | string | URL): ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState>;

package/dist/client-socket-options.js

@@ -2,5 +2,5 @@ export function parseClientOptions(options) {
     if (typeof options === 'string' || 'pathname' in options) {
         options = { address: options };
     }
-    return Object.assign({}, options);
+    return { ...options };
 }

package/dist/client-socket.d.ts

@@ -1,17 +1,18 @@
-import { AutoReconnectOptions, ClientSocketOptions, ConnectOptions } from "./client-socket-options.js";
-import { SignedAuthToken } from "@socket-mesh/auth";
-import { Socket } from "@socket-mesh/core";
-import { ClientChannels } from "./client-channels.js";
-import { SocketMapFromClient } from "./maps/socket-map.js";
-import { ClientMap } from "./maps/client-map.js";
-export declare class ClientSocket<T extends ClientMap> extends Socket<SocketMapFromClient<T>> {
+import { SignedAuthToken } from '@socket-mesh/auth';
+import { ChannelMap } from '@socket-mesh/channels';
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, Socket } from '@socket-mesh/core';
+import { ClientChannels } from './client-channels.js';
+import { AutoReconnectOptions, ClientSocketOptions, ConnectOptions } from './client-socket-options.js';
+import { ClientPrivateMap } from './maps/client-map.js';
+import { ServerPrivateMap } from './maps/server-map.js';
+export declare class ClientSocket<TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = ChannelMap, TService extends ServiceMap = {}, TState extends object = {}, TIncoming extends MethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}> extends Socket<TIncoming & ClientPrivateMap, TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService, TState> {
     private readonly _clientTransport;
-    readonly channels: ClientChannels<T>;
+    readonly channels: ClientChannels<TChannel, TIncoming, TService, TOutgoing, TPrivateOutgoing, TState>;
     constructor(address: string | URL);
-    constructor(options: ClientSocketOptions<T>);
+    constructor(options: ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState>);
     authenticate(signedAuthToken: SignedAuthToken): Promise<void>;
     get autoReconnect(): AutoReconnectOptions | false;
-    set autoReconnect(value: Partial<AutoReconnectOptions> | boolean);
+    set autoReconnect(value: boolean | Partial<AutoReconnectOptions>);
     connect(options?: ConnectOptions): void;
     get connectTimeoutMs(): number;
     set connectTimeoutMs(timeoutMs: number);

package/dist/client-socket.js

@@ -1,21 +1,23 @@
-import { ClientTransport } from "./client-transport.js";
-import { parseClientOptions } from "./client-socket-options.js";
-import { setAuthTokenHandler } from "./handlers/set-auth-token.js";
-import { removeAuthTokenHandler } from "./handlers/remove-auth-token.js";
-import { hydrateError } from "@socket-mesh/errors";
-import { Socket, wait } from "@socket-mesh/core";
-import { ClientChannels } from "./client-channels.js";
-import { publishHandler } from "./handlers/publish.js";
-import { kickOutHandler } from "./handlers/kickout.js";
+import { Socket, wait } from '@socket-mesh/core';
+import { hydrateError } from '@socket-mesh/errors';
+import { ClientChannels } from './client-channels.js';
+import { parseClientOptions } from './client-socket-options.js';
+import { ClientTransport } from './client-transport.js';
+import { kickOutHandler } from './handlers/kickout.js';
+import { publishHandler } from './handlers/publish.js';
+import { removeAuthTokenHandler } from './handlers/remove-auth-token.js';
+import { setAuthTokenHandler } from './handlers/set-auth-token.js';
 export class ClientSocket extends Socket {
+    _clientTransport;
+    channels;
     constructor(options) {
         options = parseClientOptions(options);
         options.handlers =
             Object.assign({
-                "#kickOut": kickOutHandler,
-                "#publish": publishHandler,
-                "#setAuthToken": setAuthTokenHandler,
-                "#removeAuthToken": removeAuthTokenHandler
+                '#kickOut': kickOutHandler,
+                '#publish': publishHandler,
+                '#removeAuthToken': removeAuthTokenHandler,
+                '#setAuthToken': setAuthTokenHandler
             }, options.handlers);
         const clientTransport = new ClientTransport(options);
         super(clientTransport, options);
@@ -68,7 +70,9 @@ export class ClientSocket extends Socket {
                 this._clientTransport.onError(err);
                 return;
             }
-            this.emit('removeAuthToken', { oldAuthToken });
+            if (oldAuthToken) {
+                this.emit('removeAuthToken', { oldAuthToken });
+            }
         })();
         if (this.status !== 'closed') {
             await this._clientTransport.transmit('#removeAuthToken');

package/dist/client-transport.d.ts

@@ -1,29 +1,35 @@
-import { FunctionReturnType, InvokeMethodOptions, InvokeServiceOptions, SocketTransport, SocketStatus } from "@socket-mesh/core";
-import ws from "isomorphic-ws";
-import { ClientAuthEngine } from "./client-auth-engine.js";
-import { ServerPrivateMap } from "./maps/server-map.js";
-import { AutoReconnectOptions, ClientSocketOptions, ConnectOptions } from "./client-socket-options.js";
-import { AuthToken } from "@socket-mesh/auth";
-import { SocketMapFromClient } from "./maps/socket-map.js";
-import { ClientMap } from "./maps/client-map.js";
-export declare class ClientTransport<T extends ClientMap> extends SocketTransport<SocketMapFromClient<T>> {
-    readonly authEngine: ClientAuthEngine;
-    private _uri;
-    private _wsOptions;
-    connectTimeoutMs: number;
-    private _connectTimeoutRef;
+import { AuthToken } from '@socket-mesh/auth';
+import { FunctionReturnType, InvokeMethodOptions, InvokeServiceOptions, MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, SocketStatus, SocketTransport } from '@socket-mesh/core';
+import ws from 'isomorphic-ws';
+import { ClientAuthEngine } from './client-auth-engine.js';
+import { AutoReconnectOptions, ClientSocketOptions, ConnectOptions } from './client-socket-options.js';
+import { ClientPrivateMap } from './maps/client-map.js';
+import { ServerPrivateMap } from './maps/server-map.js';
+export declare class ClientTransport<TIncoming extends MethodMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TState extends object> extends SocketTransport<TIncoming & ClientPrivateMap, TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService, TState> {
     private _autoReconnect;
     private _connectAttempts;
+    private _connectTimeoutRef;
     private _pendingReconnectTimeout;
     private _pingTimeoutMs;
+    private _uri;
+    private _wsOptions;
+    readonly authEngine: ClientAuthEngine;
+    connectTimeoutMs: number;
     isPingTimeoutDisabled: boolean;
-    constructor(options: ClientSocketOptions<T>);
+    type: 'client';
+    constructor(options: ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState>);
     get autoReconnect(): AutoReconnectOptions | false;
-    set autoReconnect(value: Partial<AutoReconnectOptions> | boolean);
+    set autoReconnect(value: boolean | Partial<AutoReconnectOptions>);
     connect(options?: ConnectOptions): void;
     get connectAttempts(): number;
     disconnect(code?: number, reason?: string): void;
     private handshake;
+    invoke<TMethod extends keyof TOutgoing>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TOutgoing[TMethod]>>, () => void];
+    invoke<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: [TServiceName, TMethod, (false | number)?], arg?: Parameters<TService[TServiceName][TMethod]>[0]): [Promise<FunctionReturnType<TService[TServiceName][TMethod]>>, () => void];
+    invoke<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: InvokeServiceOptions<TService, TServiceName, TMethod>, arg?: Parameters<TService[TServiceName][TMethod]>[0]): [Promise<FunctionReturnType<TService[TServiceName][TMethod]>>, () => void];
+    invoke<TMethod extends keyof TOutgoing>(options: InvokeMethodOptions<TOutgoing, TMethod>, arg?: Parameters<TOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TOutgoing[TMethod]>>, () => void];
+    invoke<TMethod extends keyof (TPrivateOutgoing & ServerPrivateMap)>(method: TMethod, arg: Parameters<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>>, () => void];
+    invoke<TMethod extends keyof (TPrivateOutgoing & ServerPrivateMap)>(options: InvokeMethodOptions<(TPrivateOutgoing & ServerPrivateMap), TMethod>, arg?: Parameters<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>>, () => void];
     protected onClose(code: number, reason?: Buffer): void;
     protected onOpen(): void;
     protected onPingPong(): void;
@@ -32,21 +38,13 @@ export declare class ClientTransport<T extends ClientMap> extends SocketTranspor
     set pingTimeoutMs(value: number);
     private resetReconnect;
     send(data: Buffer | string): Promise<void>;
-    setAuthorization(authToken: AuthToken): Promise<boolean>;
     setAuthorization(signedAuthToken: string, authToken?: AuthToken): Promise<boolean>;
     get status(): SocketStatus;
+    transmit<TMethod extends keyof TOutgoing>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<void>;
+    transmit<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: [TServiceName, TMethod], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<void>;
+    transmit<TMethod extends keyof (TPrivateOutgoing & ServerPrivateMap)>(method: TMethod, arg?: Parameters<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>[0]): Promise<void>;
     private tryReconnect;
-    type: 'client';
     get uri(): URL;
-    protected get webSocket(): ws.WebSocket | null;
-    protected set webSocket(value: ws.WebSocket | null);
-    transmit<TMethod extends keyof SocketMapFromClient<T>['Outgoing']>(method: TMethod, arg?: Parameters<SocketMapFromClient<T>['Outgoing'][TMethod]>[0]): Promise<void>;
-    transmit<TService extends keyof SocketMapFromClient<T>['Service'], TMethod extends keyof SocketMapFromClient<T>['Service'][TService]>(options: [TService, TMethod], arg?: Parameters<SocketMapFromClient<T>['Service'][TService][TMethod]>[0]): Promise<void>;
-    transmit<TMethod extends keyof (SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)>(method: TMethod, arg?: Parameters<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)[TMethod]>[0]): Promise<void>;
-    invoke<TMethod extends keyof SocketMapFromClient<T>['Outgoing']>(method: TMethod, arg?: Parameters<SocketMapFromClient<T>['Outgoing'][TMethod]>[0]): [Promise<FunctionReturnType<SocketMapFromClient<T>['Outgoing'][TMethod]>>, () => void];
-    invoke<TService extends keyof SocketMapFromClient<T>['Service'], TMethod extends keyof SocketMapFromClient<T>['Service'][TService]>(options: [TService, TMethod, (number | false)?], arg?: Parameters<SocketMapFromClient<T>['Service'][TService][TMethod]>[0]): [Promise<FunctionReturnType<SocketMapFromClient<T>['Service'][TService][TMethod]>>, () => void];
-    invoke<TService extends keyof SocketMapFromClient<T>['Service'], TMethod extends keyof SocketMapFromClient<T>['Service'][TService]>(options: InvokeServiceOptions<SocketMapFromClient<T>['Service'], TService, TMethod>, arg?: Parameters<SocketMapFromClient<T>['Service'][TService][TMethod]>[0]): [Promise<FunctionReturnType<SocketMapFromClient<T>['Service'][TService][TMethod]>>, () => void];
-    invoke<TMethod extends keyof SocketMapFromClient<T>['Outgoing']>(options: InvokeMethodOptions<SocketMapFromClient<T>['Outgoing'], TMethod>, arg?: Parameters<SocketMapFromClient<T>['Outgoing'][TMethod]>[0]): [Promise<FunctionReturnType<SocketMapFromClient<T>['Outgoing'][TMethod]>>, () => void];
-    invoke<TMethod extends keyof (SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)>(method: TMethod, arg: Parameters<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)[TMethod]>>, () => void];
-    invoke<TMethod extends keyof (SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)>(options: InvokeMethodOptions<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap), TMethod>, arg?: Parameters<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)[TMethod]>>, () => void];
+    protected get webSocket(): null | ws.WebSocket;
+    protected set webSocket(value: null | ws.WebSocket);
 }