@lemoncloud/chatic-sockets-lib 0.2.0 → 0.2.1

package/dist/client-socket-v2/create-client-socket-v2.js

@@ -217,8 +217,13 @@ class ClientSocketV2Impl {
             return ((_a = this.aliases[source]) !== null && _a !== void 0 ? _a : source);
         };
         this.handleRawMessage = (raw) => {
+            var _a, _b, _c, _d;
             try {
+                if (((_b = (_a = this.options).shouldHandleRaw) === null || _b === void 0 ? void 0 : _b.call(_a, { raw })) === false)
+                    return;
                 const message = parseMessage(raw);
+                if (((_d = (_c = this.options).shouldHandleMessage) === null || _d === void 0 ? void 0 : _d.call(_c, { raw, message })) === false)
+                    return;
                 const handled = this.pending.settle(message);
                 const event = { message, raw };
                 this.messageListeners.forEach(listener => listener(event));

package/dist/client-socket-v2/gateways/auth-gateway.d.ts

@@ -0,0 +1,6 @@
+import type { AuthUpdateInput, AuthUpdateResponse } from '../../lib/auth/types';
+import type { ClientSocketV2 } from '../types';
+export interface AuthGateway {
+    update(data: AuthUpdateInput): Promise<AuthUpdateResponse>;
+}
+export declare const createAuthGateway: (client: ClientSocketV2) => AuthGateway;

package/dist/client-socket-v2/gateways/auth-gateway.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthGateway = void 0;
+const create_domain_gateway_1 = require("./create-domain-gateway");
+const createAuthGateway = (client) => {
+    const gateway = (0, create_domain_gateway_1.createDomainGateway)('auth', client);
+    return {
+        update: data => gateway.request('update', data),
+    };
+};
+exports.createAuthGateway = createAuthGateway;

package/dist/client-socket-v2/gateways/channel-gateway.d.ts

@@ -0,0 +1,38 @@
+import type { ChannelCreateInput, ChannelDeleteInput, ChannelGetSelfInput, ChannelInviteInput, ChannelJoinInput, ChannelLeaveInput, ChannelListUserInput, ChannelMineInput, ChannelSyncInput, ChannelSyncProfileInput, ChannelSyncUsersInput, ChannelUnreadsInput, ChannelUpdateInput, ChannelUpdateJoinInput } from '../../lib/channel/types';
+import type { ClientSocketV2 } from '../types';
+/**
+ * channel 도메인 게이트웨이.
+ * - 모든 응답은 @lemoncloud/chatic-socials-api 소유(pass-through)이므로 제네릭 T로 호출부에서 주입한다.
+ * - 미주입 시 unknown(any 아님 — 사용 전 narrowing/캐스팅 강제). 각 메서드 주석의 $socials.<View> 가 실제 응답 타입.
+ */
+export interface ChannelGateway {
+    /** $socials.ChannelView */
+    create<T = unknown>(data: ChannelCreateInput): Promise<T>;
+    /** $socials.ChannelView */
+    update<T = unknown>(data: ChannelUpdateInput): Promise<T>;
+    /** $socials.ChannelView */
+    delete<T = unknown>(data: ChannelDeleteInput): Promise<T>;
+    /** $socials.JoinView */
+    join<T = unknown>(data: ChannelJoinInput): Promise<T>;
+    /** $socials.ChannelView */
+    leave<T = unknown>(data: ChannelLeaveInput): Promise<T>;
+    /** $socials.ChannelView */
+    getSelf<T = unknown>(data?: ChannelGetSelfInput | null): Promise<T>;
+    /** ListResult<$socials.ChannelView> */
+    mine<T = unknown>(data?: ChannelMineInput | null): Promise<T>;
+    /** ListResult<$socials.UserView> */
+    listUser<T = unknown>(data: ChannelListUserInput): Promise<T>;
+    /** $socials.ChannelView */
+    invite<T = unknown>(data: ChannelInviteInput): Promise<T>;
+    /** $socials.JoinView */
+    updateJoin<T = unknown>(data: ChannelUpdateJoinInput): Promise<T>;
+    /** $socials.UnreadsSummaryView */
+    unreads<T = unknown>(data?: ChannelUnreadsInput | null): Promise<T>;
+    /** $socials.ChannelSyncView */
+    sync<T = unknown>(data?: ChannelSyncInput | null): Promise<T>;
+    /** $socials.ChannelUsersSyncView */
+    syncUsers<T = unknown>(data?: ChannelSyncUsersInput | null): Promise<T>;
+    /** $socials.SiteProfileSyncView */
+    syncProfile<T = unknown>(data?: ChannelSyncProfileInput | null): Promise<T>;
+}
+export declare const createChannelGateway: (client: ClientSocketV2) => ChannelGateway;

package/dist/client-socket-v2/gateways/channel-gateway.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChannelGateway = void 0;
+const create_domain_gateway_1 = require("./create-domain-gateway");
+const createChannelGateway = (client) => {
+    const gateway = (0, create_domain_gateway_1.createDomainGateway)('channel', client);
+    return {
+        create: (data) => gateway.request('create', data),
+        update: (data) => gateway.request('update', data),
+        delete: (data) => gateway.request('delete', data),
+        join: (data) => gateway.request('join', data),
+        leave: (data) => gateway.request('leave', data),
+        getSelf: (data) => gateway.request('get-self', data !== null && data !== void 0 ? data : null),
+        mine: (data) => gateway.request('mine', data !== null && data !== void 0 ? data : null),
+        listUser: (data) => gateway.request('list-user', data),
+        invite: (data) => gateway.request('invite', data),
+        updateJoin: (data) => gateway.request('update-join', data),
+        unreads: (data) => gateway.request('unreads', data !== null && data !== void 0 ? data : null),
+        sync: (data) => gateway.request('sync', data !== null && data !== void 0 ? data : null),
+        syncUsers: (data) => gateway.request('sync-users', data !== null && data !== void 0 ? data : null),
+        syncProfile: (data) => gateway.request('sync-site-profile', data !== null && data !== void 0 ? data : null),
+    };
+};
+exports.createChannelGateway = createChannelGateway;

package/dist/client-socket-v2/gateways/chat-gateway.d.ts

@@ -0,0 +1,22 @@
+import type { ChatFeedInput, ChatReadInput, ChatSendInput, ChatUpdateInput, ChatDeleteInput, ChatGetInput } from '../../lib/chat/types';
+import type { ClientSocketV2 } from '../types';
+/**
+ * chat 도메인 게이트웨이.
+ * - 모든 응답은 @lemoncloud/chatic-socials-api 소유(pass-through)이므로 제네릭 T로 호출부에서 주입한다.
+ * - 미주입 시 unknown. 각 메서드 주석의 $socials.<View> 가 실제 응답 타입.
+ */
+export interface ChatGateway {
+    /** $socials.ChatView */
+    send<T = unknown>(data: ChatSendInput): Promise<T>;
+    /** $socials.ChatView */
+    get<T = unknown>(data: ChatGetInput): Promise<T>;
+    /** $socials.JoinView */
+    read<T = unknown>(data: ChatReadInput): Promise<T>;
+    /** $socials.ChatFeedResult */
+    feed<T = unknown>(data: ChatFeedInput): Promise<T>;
+    /** $socials.ChatView */
+    update<T = unknown>(data: ChatUpdateInput): Promise<T>;
+    /** $socials.ChatView */
+    delete<T = unknown>(data: ChatDeleteInput): Promise<T>;
+}
+export declare const createChatGateway: (client: ClientSocketV2) => ChatGateway;

package/dist/client-socket-v2/gateways/chat-gateway.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChatGateway = void 0;
+const create_domain_gateway_1 = require("./create-domain-gateway");
+const createChatGateway = (client) => {
+    const gateway = (0, create_domain_gateway_1.createDomainGateway)('chat', client);
+    return {
+        send: (data) => gateway.request('send', data),
+        get: (data) => gateway.request('get', data),
+        read: (data) => gateway.request('read', data),
+        feed: (data) => gateway.request('feed', data),
+        update: (data) => gateway.request('update', data),
+        delete: (data) => gateway.request('delete', data),
+    };
+};
+exports.createChatGateway = createChatGateway;

package/dist/client-socket-v2/gateways/cloud-gateway.d.ts

@@ -0,0 +1,12 @@
+import type { CloudUpdateInput } from '../../lib/cloud/types';
+import type { ClientSocketV2 } from '../types';
+/**
+ * cloud 도메인 게이트웨이.
+ * - 응답은 @lemoncloud/chatic-backend-api 소유(pass-through)이므로 제네릭 T로 호출부에서 주입한다.
+ * - 미주입 시 unknown. 주석의 $backend.<View> 가 실제 응답 타입.
+ */
+export interface CloudGateway {
+    /** $backend.CloudView */
+    update<T = unknown>(data: CloudUpdateInput): Promise<T>;
+}
+export declare const createCloudGateway: (client: ClientSocketV2) => CloudGateway;

package/dist/client-socket-v2/gateways/cloud-gateway.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCloudGateway = void 0;
+const create_domain_gateway_1 = require("./create-domain-gateway");
+const createCloudGateway = (client) => {
+    const gateway = (0, create_domain_gateway_1.createDomainGateway)('cloud', client);
+    return {
+        update: (data) => gateway.request('update', data),
+    };
+};
+exports.createCloudGateway = createCloudGateway;

package/dist/client-socket-v2/gateways/user-gateway.d.ts

@@ -0,0 +1,26 @@
+import type { UserGetSiteProfileInput, UserInviteBatchInput, UserInviteInput, UserMakeSiteInput, UserMySiteInput, UserSetSiteProfileInput, UserUpdateProfileInput, UserUpdateSiteInput } from '../../lib/user/types';
+import type { ClientSocketV2 } from '../types';
+/**
+ * user 도메인 게이트웨이.
+ * - 응답은 @lemoncloud/chatic-socials-api / chatic-backend-api 소유(pass-through)이므로 제네릭 T로 호출부에서 주입한다.
+ * - 미주입 시 unknown. 각 메서드 주석의 $socials/$backend.<View> 가 실제 응답 타입(서버가 unknown으로 둔 것은 표기 생략).
+ */
+export interface UserGateway {
+    /** $socials.ProfileView */
+    getSiteProfile<T = unknown>(data?: UserGetSiteProfileInput | null): Promise<T>;
+    /** ListResult<$backend.MySiteView> */
+    mySite<T = unknown>(data?: UserMySiteInput | null): Promise<T>;
+    /** $backend.MySiteView */
+    makeSite<T = unknown>(data: UserMakeSiteInput): Promise<T>;
+    /** $backend.MyInviteView */
+    invite<T = unknown>(data: UserInviteInput): Promise<T>;
+    /** ListResult<$backend.MyInviteView> */
+    inviteBatch<T = unknown>(data: UserInviteBatchInput): Promise<T>;
+    /** $socials.UserView */
+    updateProfile<T = unknown>(data: UserUpdateProfileInput): Promise<T>;
+    /** $backend.MySiteView */
+    updateSite<T = unknown>(data: UserUpdateSiteInput): Promise<T>;
+    /** $socials.ProfileView */
+    setSiteProfile<T = unknown>(data: UserSetSiteProfileInput): Promise<T>;
+}
+export declare const createUserGateway: (client: ClientSocketV2) => UserGateway;

package/dist/client-socket-v2/gateways/user-gateway.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUserGateway = void 0;
+const create_domain_gateway_1 = require("./create-domain-gateway");
+const createUserGateway = (client) => {
+    const gateway = (0, create_domain_gateway_1.createDomainGateway)('user', client);
+    return {
+        getSiteProfile: (data) => gateway.request('get-site-profile', data !== null && data !== void 0 ? data : null),
+        mySite: (data) => gateway.request('my-site', data !== null && data !== void 0 ? data : null),
+        makeSite: (data) => gateway.request('make-site', data),
+        invite: (data) => gateway.request('invite', data),
+        inviteBatch: (data) => gateway.request('invite-batch', data),
+        updateProfile: (data) => gateway.request('update-profile', data),
+        updateSite: (data) => gateway.request('update-site', data),
+        setSiteProfile: (data) => gateway.request('set-site-profile', data),
+    };
+};
+exports.createUserGateway = createUserGateway;

package/dist/client-socket-v2/index.d.ts

@@ -19,7 +19,15 @@ export * from './create-device-runtime';
 export * from './plans/device-sync-plan';
 export * from './gateways/create-domain-gateway';
 export * from './gateways/device-gateway';
+export * from './gateways/channel-gateway';
+export * from './gateways/auth-gateway';
+export * from './gateways/chat-gateway';
+export * from './gateways/cloud-gateway';
+export * from './gateways/user-gateway';
 export * from '../lib/types';
 export * from '../lib/device/types';
 export * from '../lib/device/contracts';
 export * from '../lib/auth/types';
+export * from '../lib/socket-actions';
+export * from '../lib/socket-inputs';
+export type { AuthUpdateInput, DeviceGetInput, DeviceSaveInput, DeviceSyncInput } from '../lib/socket-inputs';

package/dist/client-socket-v2/index.js

@@ -37,7 +37,14 @@ __exportStar(require("./create-device-runtime"), exports);
 __exportStar(require("./plans/device-sync-plan"), exports);
 __exportStar(require("./gateways/create-domain-gateway"), exports);
 __exportStar(require("./gateways/device-gateway"), exports);
+__exportStar(require("./gateways/channel-gateway"), exports);
+__exportStar(require("./gateways/auth-gateway"), exports);
+__exportStar(require("./gateways/chat-gateway"), exports);
+__exportStar(require("./gateways/cloud-gateway"), exports);
+__exportStar(require("./gateways/user-gateway"), exports);
 __exportStar(require("../lib/types"), exports);
 __exportStar(require("../lib/device/types"), exports);
 __exportStar(require("../lib/device/contracts"), exports);
 __exportStar(require("../lib/auth/types"), exports);
+__exportStar(require("../lib/socket-actions"), exports);
+__exportStar(require("../lib/socket-inputs"), exports);

package/dist/client-socket-v2/socket-transport.d.ts

@@ -3,13 +3,21 @@ export interface WebSocketTransportOptions {
     /** connect() open 이벤트 대기 timeout. 만료 시 socket close + Promise reject. 0이면 무한 대기. 기본 10000 */
     connectTimeoutMs?: number;
 }
+/**
+ * `SocketTransport` adapter over lemon-model's owned WebSocket network.
+ *
+ * Raw network concerns (socket creation, OPEN send guard, actual close, raw event mapping) are owned by
+ * `OwnedWebSocketNetwork`. This adapter only translates that single-shot network into chatic's reconnectable,
+ * code-carrying, 4-event / 5-state lifecycle. The connect timeout stays here because it belongs to the
+ * reconnect/backoff policy, not the raw transport.
+ */
 export declare class WebSocketTransport implements SocketTransport {
     readonly url: string;
     readonly protocols?: string | string[];
-    private readonly socketFactory;
+    private readonly socketFactory?;
     private _state;
-    private socket?;
-    private unbinders;
+    private network?;
+    private networkUnsubs;
     private readonly listeners;
     private readonly connectTimeoutMs;
     private connecting?;
@@ -21,5 +29,7 @@ export declare class WebSocketTransport implements SocketTransport {
     disconnect: (code?: number, reason?: string) => Promise<void>;
     send: (raw: string) => void;
     private emit;
-    private cleanupSocket;
+    /** bridge chatic's `SocketLike` factory to the owned network's `WebSocketClosable` factory */
+    private buildSocketFactory;
+    private cleanupNetwork;
 }

package/dist/client-socket-v2/socket-transport.js

@@ -10,30 +10,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketTransport = void 0;
-const common_1 = require("./common");
-const OPEN_STATE = 1;
-const bindSocketListener = (socket, type, listener) => {
-    if (socket.addEventListener) {
-        socket.addEventListener(type, listener);
-        return () => { var _a; return (_a = socket.removeEventListener) === null || _a === void 0 ? void 0 : _a.call(socket, type, listener); };
-    }
-    const key = `on${type}`;
-    const prev = socket[key];
-    socket[key] = listener;
-    return () => {
-        if (socket[key] === listener)
-            socket[key] = prev !== null && prev !== void 0 ? prev : null;
-    };
-};
+const lemon_model_1 = require("lemon-model");
 const DEFAULT_CONNECT_TIMEOUT_MS = 10000;
+/**
+ * `SocketTransport` adapter over lemon-model's owned WebSocket network.
+ *
+ * Raw network concerns (socket creation, OPEN send guard, actual close, raw event mapping) are owned by
+ * `OwnedWebSocketNetwork`. This adapter only translates that single-shot network into chatic's reconnectable,
+ * code-carrying, 4-event / 5-state lifecycle. The connect timeout stays here because it belongs to the
+ * reconnect/backoff policy, not the raw transport.
+ */
 class WebSocketTransport {
-    constructor(url, protocols, socketFactory = context => new globalThis.WebSocket(context.url, context.protocols), options) {
+    constructor(url, protocols, socketFactory, options) {
         var _a;
         this.url = url;
         this.protocols = protocols;
         this.socketFactory = socketFactory;
         this._state = 'idle';
-        this.unbinders = [];
+        this.networkUnsubs = [];
         this.listeners = new Map();
         this.on = (type, listener) => {
             var _a;
@@ -51,17 +45,23 @@ class WebSocketTransport {
                 return;
             if (this.connecting)
                 return this.connecting;
-            this.cleanupSocket();
+            this.cleanupNetwork();
             this._state = 'connecting';
-            const socket = this.socketFactory({ url: this.url, protocols: this.protocols });
-            this.socket = socket;
+            const network = (0, lemon_model_1.createOwnedWebSocketNetwork)({
+                url: this.url,
+                protocols: this.protocols,
+                socketFactory: this.buildSocketFactory(),
+                connectTimeoutMs: 0, // connect timeout is owned here (reconnect policy), not by the network
+            });
+            this.network = network;
             this.connecting = new Promise((resolve, reject) => {
-                let connectSettled = false;
+                var _a;
+                let settled = false;
                 let timeoutTimer;
                 const settleConnect = (handler) => {
-                    if (connectSettled)
+                    if (settled)
                         return;
-                    connectSettled = true;
+                    settled = true;
                     if (timeoutTimer)
                         clearTimeout(timeoutTimer);
                     this.connecting = undefined;
@@ -71,75 +71,73 @@ class WebSocketTransport {
                 this.cancelConnecting = error => settleConnect(() => reject(error));
                 if (this.connectTimeoutMs > 0) {
                     timeoutTimer = setTimeout(() => {
-                        if (connectSettled)
-                            return;
                         const error = new Error(`408 CONNECT TIMEOUT - WebSocketTransport.connect() after ${this.connectTimeoutMs}ms`);
                         settleConnect(() => reject(error));
-                        try {
-                            socket.close(1000, 'connect-timeout');
-                        }
-                        catch (_a) {
-                            /** ignore — best-effort cleanup */
-                        }
+                        network.close(1000, 'connect-timeout');
                     }, this.connectTimeoutMs);
                 }
-                this.unbinders = [
-                    bindSocketListener(socket, 'open', () => {
-                        this._state = 'connected';
-                        this.emit('open', undefined);
-                        settleConnect(() => resolve());
-                    }),
-                    bindSocketListener(socket, 'close', event => {
-                        this._state = 'closed';
-                        this.emit('close', {
-                            code: event === null || event === void 0 ? void 0 : event.code,
-                            reason: event === null || event === void 0 ? void 0 : event.reason,
-                            wasClean: event === null || event === void 0 ? void 0 : event.wasClean,
-                        });
-                        settleConnect(() => resolve());
-                    }),
-                    bindSocketListener(socket, 'error', event => {
+                const unsubOpen = (_a = network.onOpen) === null || _a === void 0 ? void 0 : _a.call(network, () => {
+                    this._state = 'connected';
+                    this.emit('open', undefined);
+                    settleConnect(() => resolve());
+                });
+                this.networkUnsubs = [
+                    network.onMessage(raw => this.emit('message', { data: raw })),
+                    network.onError((event, context) => {
                         var _a;
-                        const error = (_a = event === null || event === void 0 ? void 0 : event.error) !== null && _a !== void 0 ? _a : new Error(`socket transport error`);
+                        if (context.scope === 'ownedWebSocket.close') {
+                            const close = event;
+                            this._state = 'closed';
+                            this.emit('close', { code: close === null || close === void 0 ? void 0 : close.code, reason: close === null || close === void 0 ? void 0 : close.reason, wasClean: close === null || close === void 0 ? void 0 : close.wasClean });
+                            settleConnect(() => resolve()); // close-before-open resolves connect (reconnect drives off state)
+                            return;
+                        }
+                        const error = (_a = event === null || event === void 0 ? void 0 : event.error) !== null && _a !== void 0 ? _a : (event instanceof Error ? event : new Error(`socket transport error`));
                         this.emit('error', { error });
                         if (this._state !== 'connected')
                             this._state = 'closed';
                         settleConnect(() => reject(error));
                     }),
-                    bindSocketListener(socket, 'message', event => {
-                        this.emit('message', { data: (0, common_1.asString)(event === null || event === void 0 ? void 0 : event.data, '') });
-                    }),
                 ];
+                if (unsubOpen)
+                    this.networkUnsubs.push(unsubOpen);
             });
             return this.connecting;
         });
         this.disconnect = (code, reason) => __awaiter(this, void 0, void 0, function* () {
             var _b;
-            if (!this.socket) {
+            if (!this.network) {
                 this._state = 'closed';
                 return;
             }
             this._state = 'closing';
-            const socket = this.socket;
-            socket.close(code, reason);
+            const network = this.network;
+            network.close(code, reason);
             (_b = this.cancelConnecting) === null || _b === void 0 ? void 0 : _b.call(this, new Error(`499 CLIENT CLOSED REQUEST - disconnect during connecting`));
-            this.cleanupSocket();
+            this.cleanupNetwork();
             this._state = 'closed';
             this.emit('close', { code, reason, wasClean: true });
         });
         this.send = (raw) => {
-            if (!this.socket || this.socket.readyState !== undefined && this.socket.readyState !== OPEN_STATE) {
+            if (!this.network || this.network.readyState !== 'open') {
                 throw new Error(`503 SOCKET NOT CONNECTED - WebSocketTransport.send()`);
             }
-            this.socket.send(raw);
+            this.network.send(raw);
         };
         this.emit = (type, event) => {
             var _a;
             (_a = this.listeners.get(type)) === null || _a === void 0 ? void 0 : _a.forEach(listener => listener(event));
         };
-        this.cleanupSocket = () => {
-            this.unbinders.splice(0).forEach(unbind => unbind());
-            this.socket = undefined;
+        /** bridge chatic's `SocketLike` factory to the owned network's `WebSocketClosable` factory */
+        this.buildSocketFactory = () => {
+            const factory = this.socketFactory;
+            if (!factory)
+                return undefined;
+            return context => factory({ url: context.url, protocols: context.protocols });
+        };
+        this.cleanupNetwork = () => {
+            this.networkUnsubs.splice(0).forEach(unsub => unsub());
+            this.network = undefined;
         };
         this.connectTimeoutMs = (_a = options === null || options === void 0 ? void 0 : options.connectTimeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_CONNECT_TIMEOUT_MS;
     }

package/dist/client-socket-v2/types.d.ts

@@ -2,20 +2,27 @@ import type { ResolveSocketPacketType, SocketMessage, SocketPacketInputType, Soc
 import type { DeviceBootstrapInput } from '../lib/device/types';
 export declare type ClientSocketState = 'idle' | 'connecting' | 'connected' | 'closing' | 'closed';
 export interface SocketLike {
-    readonly readyState?: number;
+    readonly readyState: number;
     send(data: string): void;
     close(code?: number, reason?: string): void;
-    addEventListener?(type: 'open' | 'close' | 'error' | 'message', listener: (event?: any) => void): void;
-    removeEventListener?(type: 'open' | 'close' | 'error' | 'message', listener: (event?: any) => void): void;
-    onopen?: ((event?: any) => void) | null;
-    onclose?: ((event?: any) => void) | null;
-    onerror?: ((event?: any) => void) | null;
-    onmessage?: ((event?: any) => void) | null;
+    addEventListener(type: 'open' | 'close' | 'error' | 'message', listener: (event?: any) => void, options?: {
+        once?: boolean;
+    }): void;
+    removeEventListener(type: 'open' | 'close' | 'error' | 'message', listener: (event?: any) => void): void;
 }
 export interface SocketFactoryContext {
     url: string;
     protocols?: string | string[];
 }
+/** context for the pre-parse raw ownership filter */
+export interface ClientSocketInboundFilterContext {
+    raw: string;
+}
+/** context for the post-parse message ownership filter */
+export interface ClientSocketMessageFilterContext<T = any> {
+    raw: string;
+    message: SocketMessage<T>;
+}
 export interface SocketTransportEventMap {
     open: void;
     close: {
@@ -64,6 +71,8 @@ export interface ClientSocketOptions {
     protocols?: string | string[];
     device?: DeviceBootstrapInput | null;
     socketFactory?: (context: SocketFactoryContext) => SocketLike;
+    shouldHandleRaw?: (context: ClientSocketInboundFilterContext) => boolean;
+    shouldHandleMessage?: (context: ClientSocketMessageFilterContext) => boolean;
     aliases?: Partial<Record<SocketPacketInputType | string, SocketPacketType>>;
     timerScheduler?: SharedTimerScheduler;
     requestTimeoutMs?: number;