@socket-mesh/client 18.1.5 → 19.0.0

package/dist/client-transport.d.ts

@@ -1,28 +1,28 @@
-import { FunctionReturnType, InvokeMethodOptions, InvokeServiceOptions, SocketTransport, SocketStatus, MethodMap, ServiceMap, PublicMethodMap, PrivateMethodMap } 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 { ClientPrivateMap } from "./maps/client-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> {
-    readonly authEngine: ClientAuthEngine;
-    private _uri;
-    private _wsOptions;
-    connectTimeoutMs: number;
-    private _connectTimeoutRef;
+import { AuthToken } from '@socket-mesh/auth';
+import { BaseSocketTransport, InvokeMethodOptions, InvokeServiceOptions, 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';
+export declare class ClientTransport<TState extends object = {}> extends BaseSocketTransport<TState> implements SocketTransport<{}, {}, 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<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState>);
+    type: 'client';
+    constructor(options: ClientSocketOptions<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(methodOptions: [string, string, (false | number)?] | InvokeMethodOptions | InvokeServiceOptions | string, arg?: unknown): [Promise<unknown>, () => void];
     protected onClose(code: number, reason?: Buffer): void;
     protected onOpen(): void;
     protected onPingPong(): void;
@@ -31,21 +31,11 @@ export declare class ClientTransport<TIncoming extends MethodMap, TService exten
     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(serviceAndMethod: [string, string] | string, arg?: unknown): 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 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>;
-    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, (number | false)?], 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 get webSocket(): null | ws.WebSocket;
+    protected set webSocket(value: null | ws.WebSocket);
 }

package/dist/client-transport.js

@@ -1,16 +1,28 @@
-import { SocketTransport } from "@socket-mesh/core";
-import ws from "isomorphic-ws";
-import { LocalStorageAuthEngine, isAuthEngine } from "./client-auth-engine.js";
-import { hydrateError, socketProtocolErrorStatuses } from "@socket-mesh/errors";
-export class ClientTransport extends SocketTransport {
+import { BaseSocketTransport, toError } from '@socket-mesh/core';
+import { hydrateError, SocketClosedError, SocketProtocolErrorStatuses } from '@socket-mesh/errors';
+import ws from 'isomorphic-ws';
+import { isAuthEngine, LocalStorageAuthEngine } from './client-auth-engine.js';
+import { parseAutoReconnectOptions } from './client-socket-options.js';
+export class ClientTransport extends BaseSocketTransport {
+    _autoReconnect;
+    _connectAttempts;
+    _connectTimeoutRef = null;
+    _pendingReconnectTimeout;
+    _pingTimeoutMs;
+    _uri;
+    _wsOptions;
+    authEngine;
+    connectTimeoutMs;
+    isPingTimeoutDisabled;
+    type;
     constructor(options) {
         super(options);
         this.type = 'client';
         this._uri = typeof options.address === 'string' ? new URL(options.address) : options.address;
         this.authEngine =
-            isAuthEngine(options.authEngine) ?
-                options.authEngine :
-                new LocalStorageAuthEngine(Object.assign({ authTokenName: `socketmesh.authToken${this._uri.protocol}${this._uri.hostname}` }, options.authEngine));
+            isAuthEngine(options.authEngine)
+                ? options.authEngine
+                : new LocalStorageAuthEngine(Object.assign({ authTokenName: `socketmesh.authToken${this._uri.protocol}${this._uri.hostname}` }, options.authEngine));
         this.connectTimeoutMs = options.connectTimeoutMs ?? 20000;
         this._pingTimeoutMs = this.connectTimeoutMs;
         if (options.wsOptions) {
@@ -18,41 +30,31 @@ export class ClientTransport extends SocketTransport {
         }
         this._connectAttempts = 0;
         this._pendingReconnectTimeout = null;
-        this.autoReconnect = options.autoReconnect;
+        this._autoReconnect = parseAutoReconnectOptions(options.autoReconnect);
         this.isPingTimeoutDisabled = (options.isPingTimeoutDisabled === true);
     }
     get autoReconnect() {
         return this._autoReconnect;
     }
     set autoReconnect(value) {
-        if (value) {
-            this._autoReconnect = Object.assign({
-                initialDelay: 10000,
-                randomness: 10000,
-                multiplier: 1.5,
-                maxDelayMs: 60000
-            }, value === true ? {} : value);
-        }
-        else {
-            this._autoReconnect = false;
-        }
+        this._autoReconnect = parseAutoReconnectOptions(value);
     }
     connect(options) {
         let timeoutMs = this.connectTimeoutMs;
         if (options) {
-            let changeOptions = false;
+            let didOptionsChange = false;
             if (options.connectTimeoutMs) {
                 timeoutMs = options.connectTimeoutMs;
             }
             if (options.address) {
-                changeOptions = true;
+                didOptionsChange = true;
                 this._uri = typeof options.address === 'string' ? new URL(options.address) : options.address;
             }
             if (options.wsOptions) {
-                changeOptions = true;
+                didOptionsChange = true;
                 this._wsOptions = options.wsOptions;
             }
-            if (changeOptions && this.status !== 'closed') {
+            if (didOptionsChange && this.status !== 'closed') {
                 this.disconnect(1000, 'Socket was disconnected by the client to initiate a new connection');
             }
         }
@@ -84,9 +86,29 @@ export class ClientTransport extends SocketTransport {
         }
         return status;
     }
+    invoke(methodOptions, arg) {
+        let wasAborted = false;
+        let abort = () => { wasAborted = true; };
+        const promise = Promise.resolve()
+            .then(() => {
+            if (this.status === 'closed') {
+                this.connect();
+                return this.socket.listen('connect').once();
+            }
+        })
+            .then(() => {
+            const result = super.invoke(methodOptions, arg);
+            abort = result[1];
+            if (wasAborted) {
+                abort();
+            }
+            return result[0];
+        });
+        return [promise, () => abort()];
+    }
     onClose(code, reason) {
         const status = this.status;
-        let reconnecting = false;
+        let isReconnecting = false;
         super.onClose(code, reason);
         // Try to reconnect
         // on server ping timeout (4000)
@@ -101,30 +123,32 @@ export class ClientTransport extends SocketTransport {
                 // status, don't wait before trying to reconnect - These could happen
                 // if the client wakes up after a period of inactivity and in this case we
                 // want to re-establish the connection as soon as possible.
-                reconnecting = !!this.autoReconnect;
+                isReconnecting = !!this.autoReconnect;
                 this.tryReconnect(0);
                 // Codes 4500 and above will be treated as permanent disconnects.
                 // Socket will not try to auto-reconnect.
             }
             else if (code !== 1000 && code < 4500) {
-                reconnecting = !!this.autoReconnect;
+                isReconnecting = !!this.autoReconnect;
                 this.tryReconnect();
             }
         }
-        if (!reconnecting) {
-            const strReason = reason?.toString() || socketProtocolErrorStatuses[code];
+        if (!isReconnecting) {
+            const strReason = reason?.toString() || SocketProtocolErrorStatuses[code];
             this.onDisconnect(status, code, strReason);
         }
     }
     onOpen() {
         super.onOpen();
-        clearTimeout(this._connectTimeoutRef);
-        this._connectTimeoutRef = null;
+        if (this._connectTimeoutRef) {
+            clearTimeout(this._connectTimeoutRef);
+            this._connectTimeoutRef = null;
+        }
         this.resetReconnect();
         this.resetPingTimeout(this.isPingTimeoutDisabled ? false : this.pingTimeoutMs, 4000);
         let authError;
         this.handshake()
-            .then(status => {
+            .then((status) => {
             this.id = status.id;
             this.pingTimeoutMs = status.pingTimeoutMs;
             if ('authToken' in status && status.authToken) {
@@ -138,12 +162,11 @@ export class ClientTransport extends SocketTransport {
             .then(() => {
             this.setReadyStatus(this.pingTimeoutMs, authError);
         })
-            .catch(err => {
-            if (err.statusCode == null) {
-                err.statusCode = 4003;
-            }
-            this.onError(err);
-            this.disconnect(err.statusCode, err.toString());
+            .catch((err) => {
+            const error = toError(err);
+            const statusCode = (err != null && typeof err === 'object' && 'statusCode' in err) ? err.statusCode : 4003;
+            this.onError(error);
+            this.disconnect(statusCode, error.toString());
         });
     }
     onPingPong() {
@@ -166,6 +189,9 @@ export class ClientTransport extends SocketTransport {
         this._connectAttempts = 0;
     }
     async send(data) {
+        if (!this.webSocket) {
+            throw new SocketClosedError('Web socket is closed.');
+        }
         this.webSocket.send(data);
     }
     async setAuthorization(signedAuthToken, authToken) {
@@ -174,8 +200,8 @@ export class ClientTransport extends SocketTransport {
         if (changed) {
             this.triggerAuthenticationEvents(false, wasAuthenticated);
             // Even if saving the auth token failes we do NOT want to throw an exception.
-            this.authEngine.saveToken(this.signedAuthToken)
-                .catch(err => {
+            this.authEngine.saveToken(signedAuthToken)
+                .catch((err) => {
                 this.onError(err);
             });
         }
@@ -187,6 +213,13 @@ export class ClientTransport extends SocketTransport {
         }
         return super.status;
     }
+    async transmit(serviceAndMethod, arg) {
+        if (this.status === 'closed') {
+            this.connect();
+            await this.socket.listen('connect').once();
+        }
+        await super.transmit(serviceAndMethod, arg);
+    }
     tryReconnect(initialDelay) {
         if (!this.autoReconnect) {
             return;
@@ -221,7 +254,7 @@ export class ClientTransport extends SocketTransport {
             }
         }
         super.webSocket = value;
-        if (this.webSocket && this.webSocket.on) {
+        if (this.webSocket?.on) {
             // WebSockets will throw an error if they are closed before they are completely open.
             // We hook into these events to supress those errors and clean them up after a connection is established.
             function onOpenCloseError() {
@@ -234,29 +267,4 @@ export class ClientTransport extends SocketTransport {
             this.webSocket.on('error', onOpenCloseError);
         }
     }
-    async transmit(serviceAndMethod, arg) {
-        if (this.status === 'closed') {
-            this.connect();
-            await this.socket.listen('connect').once();
-        }
-        await super.transmit(serviceAndMethod, arg);
-    }
-    invoke(methodOptions, arg) {
-        let abort;
-        return [
-            Promise.resolve()
-                .then(() => {
-                if (this.status === 'closed') {
-                    this.connect();
-                    return this.socket.listen('connect').once();
-                }
-            })
-                .then(() => {
-                const result = super.invoke(methodOptions, arg);
-                abort = result[1];
-                return result[0];
-            }),
-            abort
-        ];
-    }
 }

package/dist/handlers/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./kickout.js";
-export * from "./publish.js";
-export * from "./remove-auth-token.js";
-export * from "./set-auth-token.js";
+export * from './kickout.js';
+export * from './publish.js';
+export * from './remove-auth-token.js';
+export * from './set-auth-token.js';

package/dist/handlers/index.js

@@ -1,4 +1,4 @@
-export * from "./kickout.js";
-export * from "./publish.js";
-export * from "./remove-auth-token.js";
-export * from "./set-auth-token.js";
+export * from './kickout.js';
+export * from './publish.js';
+export * from './remove-auth-token.js';
+export * from './set-auth-token.js';

package/dist/handlers/kickout.d.ts

@@ -1,7 +1,6 @@
-import { RequestHandlerArgs } from "@socket-mesh/core";
-import { ClientSocket } from "../client-socket.js";
-import { ClientTransport } from "../client-transport.js";
-import { ClientPrivateMap, KickOutOptions } from "../maps/client-map.js";
-import { ServerPrivateMap } from "../maps/server-map.js";
-import { ChannelMap } from "@socket-mesh/channels";
-export declare function kickOutHandler({ socket, options }: RequestHandlerArgs<KickOutOptions, ClientPrivateMap, {}, ServerPrivateMap, {}, {}, ClientSocket<{}, ChannelMap>, ClientTransport<{}, {}, {}, {}, {}>>): Promise<void>;
+import { ChannelMap } from '@socket-mesh/channels';
+import { RequestHandlerArgs } from '@socket-mesh/core';
+import { ClientSocket } from '../client-socket.js';
+import { ClientTransport } from '../client-transport.js';
+import { KickOutOptions } from '../maps/client-map.js';
+export declare function kickOutHandler({ options, socket }: RequestHandlerArgs<KickOutOptions, {}, ClientSocket<{}, {}, ChannelMap>, ClientTransport<{}>>): Promise<void>;

package/dist/handlers/kickout.js

@@ -1,5 +1,3 @@
-export async function kickOutHandler({ socket, options }) {
-    if (typeof options.channel !== 'string')
-        return;
+export async function kickOutHandler({ options, socket }) {
     socket.channels.kickOut(options.channel, options.message);
 }

package/dist/handlers/publish.d.ts

@@ -1,7 +1,5 @@
-import { ChannelMap, PublishOptions } from "@socket-mesh/channels";
-import { RequestHandlerArgs } from "@socket-mesh/core";
-import { ClientSocket } from "../client-socket.js";
-import { ClientTransport } from "../client-transport.js";
-import { ClientPrivateMap } from "../maps/client-map.js";
-import { ServerPrivateMap } from "../maps/server-map.js";
-export declare function publishHandler({ socket, options }: RequestHandlerArgs<PublishOptions, ClientPrivateMap, {}, ServerPrivateMap, {}, {}, ClientSocket<{}, ChannelMap>, ClientTransport<{}, {}, {}, {}, {}>>): Promise<void>;
+import { ChannelMap, PublishOptions } from '@socket-mesh/channels';
+import { RequestHandlerArgs } from '@socket-mesh/core';
+import { ClientSocket } from '../client-socket.js';
+import { ClientTransport } from '../client-transport.js';
+export declare function publishHandler({ options, socket }: RequestHandlerArgs<PublishOptions, {}, ClientSocket<{}, {}, ChannelMap>, ClientTransport<{}>>): Promise<void>;

package/dist/handlers/publish.js

@@ -1,3 +1,3 @@
-export async function publishHandler({ socket, options }) {
+export async function publishHandler({ options, socket }) {
     socket.channels.write(options.channel, options.data);
 }

package/dist/handlers/remove-auth-token.d.ts

@@ -1,2 +1,2 @@
-import { RequestHandlerArgs } from "@socket-mesh/core";
+import { RequestHandlerArgs } from '@socket-mesh/core';
 export declare function removeAuthTokenHandler({ transport }: RequestHandlerArgs<void>): Promise<void>;

package/dist/handlers/set-auth-token.d.ts

@@ -1,3 +1,3 @@
-import { SignedAuthToken } from "@socket-mesh/auth";
-import { RequestHandlerArgs } from "@socket-mesh/core";
-export declare function setAuthTokenHandler({ transport, options }: RequestHandlerArgs<SignedAuthToken>): Promise<void>;
+import { SignedAuthToken } from '@socket-mesh/auth';
+import { RequestHandlerArgs } from '@socket-mesh/core';
+export declare function setAuthTokenHandler({ options, transport }: RequestHandlerArgs<SignedAuthToken>): Promise<void>;

package/dist/handlers/set-auth-token.js

@@ -1,3 +1,3 @@
-export async function setAuthTokenHandler({ transport, options }) {
+export async function setAuthTokenHandler({ options, transport }) {
     await transport.setAuthorization(options);
 }

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export * from "./handlers/index.js";
-export * from "./maps/index.js";
-export * from "./plugins/index.js";
-export * from "./client-auth-engine.js";
-export * from "./client-channels.js";
-export * from "./client-socket.js";
-export * from "./client-socket-options.js";
-export * from "./client-transport.js";
+export * from './client-auth-engine.js';
+export * from './client-channels.js';
+export * from './client-socket-options.js';
+export * from './client-socket.js';
+export * from './client-transport.js';
+export * from './handlers/index.js';
+export * from './maps/index.js';
+export * from './plugins/index.js';

package/dist/index.js

@@ -1,8 +1,8 @@
-export * from "./handlers/index.js";
-export * from "./maps/index.js";
-export * from "./plugins/index.js";
-export * from "./client-auth-engine.js";
-export * from "./client-channels.js";
-export * from "./client-socket.js";
-export * from "./client-socket-options.js";
-export * from "./client-transport.js";
+export * from './client-auth-engine.js';
+export * from './client-channels.js';
+export * from './client-socket-options.js';
+export * from './client-socket.js';
+export * from './client-transport.js';
+export * from './handlers/index.js';
+export * from './maps/index.js';
+export * from './plugins/index.js';

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

@@ -1,12 +1,12 @@
-import { SignedAuthToken } from "@socket-mesh/auth";
-import { PublishOptions } from "@socket-mesh/channels";
-export interface KickOutOptions {
-    channel: string;
-    message: string;
-}
+import { SignedAuthToken } from '@socket-mesh/auth';
+import { PublishOptions } from '@socket-mesh/channels';
 export type ClientPrivateMap = {
     '#kickOut': (options: KickOutOptions) => void;
-    '#setAuthToken': (token: SignedAuthToken) => void;
-    '#removeAuthToken': () => void;
     '#publish': (options: PublishOptions) => void;
+    '#removeAuthToken': () => void;
+    '#setAuthToken': (token: SignedAuthToken) => void;
 };
+export interface KickOutOptions {
+    channel: string;
+    message: string;
+}

package/dist/maps/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./client-map.js";
-export * from "./server-map.js";
+export * from './client-map.js';
+export * from './server-map.js';

package/dist/maps/index.js

@@ -1,2 +1,2 @@
-export * from "./client-map.js";
-export * from "./server-map.js";
+export * from './client-map.js';
+export * from './server-map.js';

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

@@ -1,22 +1,19 @@
-import { SignedAuthToken } from "@socket-mesh/auth";
-import { ChannelOptions, PublishOptions } from "@socket-mesh/channels";
-export interface HandshakeOptions {
+import { SignedAuthToken } from '@socket-mesh/auth';
+import { ChannelOptions, PublishOptions } from '@socket-mesh/channels';
+export interface HandshakeAuthenticatedStatus {
     authToken: SignedAuthToken;
-}
-export type HandshakeStatus = HandshakeErrorStatus | HandshakeAuthenticatedStatus;
-export interface HandshakeErrorStatus {
     id: string;
     pingTimeoutMs: number;
-    authError: Error;
 }
-export interface HandshakeAuthenticatedStatus {
+export interface HandshakeErrorStatus {
+    authError: Error;
     id: string;
     pingTimeoutMs: number;
-    authToken: SignedAuthToken;
 }
-export interface SubscribeOptions extends ChannelOptions {
-    channel: string;
+export interface HandshakeOptions {
+    authToken: SignedAuthToken;
 }
+export type HandshakeStatus = HandshakeAuthenticatedStatus | HandshakeErrorStatus;
 export type ServerPrivateMap = {
     '#authenticate': (authToken: string) => void;
     '#handshake': (options: HandshakeOptions) => HandshakeStatus;
@@ -25,3 +22,6 @@ export type ServerPrivateMap = {
     '#subscribe': (options: SubscribeOptions) => void;
     '#unsubscribe': (channelName: string) => void;
 };
+export interface SubscribeOptions extends ChannelOptions {
+    channel: string;
+}

package/dist/plugins/batching-plugin.d.ts

@@ -1,41 +1,39 @@
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
-import { Plugin, SendRequestPluginArgs, SendResponsePluginArgs } from "@socket-mesh/core";
-export interface BatchingPluginOptions {
-    batchOnHandshakeDuration?: number | false;
+import { Plugin, SendRequestPluginArgs, SendResponsePluginArgs } from '@socket-mesh/core';
+export interface BatchingPluginOptions<TType = string> {
     batchInterval?: number;
+    batchOnHandshakeDuration?: false | number;
+    type: TType;
 }
-export declare abstract class BatchingPlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> implements Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
-    batchOnHandshakeDuration: number | boolean;
-    batchInterval: number;
+export declare abstract class BatchingPlugin<TType extends string> implements Plugin {
     private _batchingIntervalId;
     private _handshakeTimeoutId;
     private _isBatching;
-    constructor(options?: BatchingPluginOptions);
-    type: string;
+    batchInterval: number;
+    batchOnHandshakeDuration: boolean | number;
+    type: TType;
+    constructor(options: BatchingPluginOptions<TType>);
     cancelBatching(): void;
     protected abstract flush(): void;
     get isBatching(): boolean;
-    onReady(): void;
     onDisconnected(): void;
-    startBatching(): void;
+    onReady(): void;
     private start;
-    stopBatching(): void;
+    startBatching(): void;
     private stop;
+    stopBatching(): void;
 }
-export declare class RequestBatchingPlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends BatchingPlugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
-    private _requests;
+export declare class RequestBatchingPlugin extends BatchingPlugin<'requestBatching'> {
     private _continue;
-    constructor(options?: BatchingPluginOptions);
+    private _requests;
+    constructor(options?: Omit<BatchingPluginOptions, 'type'>);
     cancelBatching(): void;
     protected flush(): void;
-    sendRequest({ requests, cont }: SendRequestPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
-    type: 'requestBatching';
+    sendRequest({ cont, requests }: SendRequestPluginArgs): void;
 }
-export declare class ResponseBatchingPlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends BatchingPlugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
-    private _responses;
+export declare class ResponseBatchingPlugin extends BatchingPlugin<'responseBatching'> {
     private _continue;
-    constructor(options?: BatchingPluginOptions);
+    private _responses;
+    constructor(options?: Omit<BatchingPluginOptions, 'type'>);
     protected flush(): void;
-    sendResponse({ responses, cont }: SendResponsePluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
-    type: 'responseBatching';
+    sendResponse({ cont, responses }: SendResponsePluginArgs): void;
 }