@wildix/xbees-conversations-utils 1.1.85 → 1.1.86

package/README.md

@@ -1 +1,118 @@
-# TDB
+# `streamRateLimitHandlingProxy`
+
+This package wraps a `StreamChat` client into a proxy that adds shared rate-limit protection around Stream SDK calls without changing the normal sync API contract. Async calls go through retry / cooldown handling, while sync methods stay sync. If a proxied call returns a channel-like object, that object is wrapped too, so the same protection continues on nested channel operations.
+
+## Public entry points
+
+- `createRateLimitedStreamProxy(stream, {redis, logger})`
+  Creates the proxy, attaches response interceptors once, and returns a rate-limit-aware `StreamChat` instance.
+  Code: `src/streamRateLimitHandlingProxy/createRateLimitedStreamProxy.ts`
+- `withStreamRateLimitOptions(options)`
+  Builds a marker token that can be passed as the last argument of a proxied async call to override retry behavior for that single call.
+  Code: `src/streamRateLimitHandlingProxy/withStreamRateLimitOptions.ts`
+- Public exports are re-exported from `src/streamRateLimitHandlingProxy/index.ts` and then from `src/index.ts`.
+
+## How it works
+
+1. `createRateLimitedStreamProxy(...)` tries to register axios response interceptors on the underlying Stream transport.
+2. The proxy classifies Stream methods into groups generated in `generatedMethodNames.ts`:
+   - pure sync methods: returned as-is;
+   - sync methods returning channel/client objects: returned sync, but results are re-wrapped;
+   - async methods: executed through the rate-limit handler.
+3. Every async call is normalized through `executeWithRateLimitHandling(...)`.
+4. Returned channel-like objects are detected and wrapped again, so calls like `stream.channel(...).sendMessage(...)` stay protected end to end.
+
+If the underlying Stream SDK transport does not expose an axios instance, the proxy still works, but shared protection driven by response headers becomes less effective because no interceptors can be attached.
+
+## Protection layers
+
+### 1. Soft global throttle
+
+The interceptor reads `x-ratelimit-limit` and `x-ratelimit-remaining`. When usage becomes high, it enables a short shared Redis cooldown before real 429 responses start happening. This smooths bursts instead of waiting for hard throttling.
+
+- Trigger source: response headers on successful or failed requests
+- Effect:
+  - usage `>= 95%`: delay next requests by `3000ms`;
+  - usage between `85%` and `95%`: delay by `1500ms`;
+  - usage between `70%` and `85%`: delay by `500ms`;
+  - usage `< 70%`: clear soft throttle.
+- Scope: global shared throttle
+- Code: `helpers/processStreamRateLimitHeaders.ts`
+
+### 2. Hard per-operation 429 cooldown
+
+If Stream returns HTTP 429, the handler converts that error into `RateLimitExceededException`, calculates retry delay from `retry-after` or fallback values, stores a Redis cooldown for the specific operation, and optionally retries the call.
+
+If another worker hits the same operation while that cooldown is still active, the request is short-circuited locally before touching Stream. To keep that synthetic error useful, the latest real `x-ratelimit-*` snapshot is cached in Redis next to the cooldown and reused in the locally generated exception.
+
+- Trigger source: HTTP 429 / `retry-after` / `x-ratelimit-*`
+- Effect: per-operation block, optional retry, synthetic local short-circuit when cooldown is already known
+- Scope: operation-level
+- Code:
+  - execution flow: `helpers/executeWithRateLimitHandling.ts`
+  - 429 parsing: `helpers/processStreamRateLimitException.ts`
+  - exception creation: `helpers/createRateLimitExceededException.ts`
+  - snapshot serialization: `helpers/rateLimitSnapshot.ts`
+
+### 3. App-wide budget cooldown
+
+The interceptor also reads `x-budget-*` headers. If overall Stream app budget usage becomes high, it enables a global Redis cooldown. While this cooldown is active, requests are delayed in small sleep chunks so they can resume early if a fresher response lowers the cooldown.
+
+- Trigger source: `x-budget-limit-ms`, `x-budget-remaining-ms`, `x-budget-used-ms`
+- Effect:
+  - usage `>= 80%`: enable strong cooldown (`30s-60s`);
+  - usage between `70%` and `80%`: keep a relaxed cooldown (`5s-10s`);
+  - usage between `60%` and `70%`: keep a minimal cooldown (`1s-2s`);
+  - usage `< 60%`: clear cooldown.
+- Scope: whole application, not a single operation
+- Code: `helpers/processStreamBudgetHeaders.ts`
+
+## Retry and cooldown behavior
+
+- Local preflight checks happen before request execution when `enableCooldown` is on:
+  - active per-operation cooldown: fail fast with a synthetic `RateLimitExceededException`;
+  - active soft throttle: delay request briefly;
+  - active budget cooldown: delay request globally.
+- Real 429 responses can still be retried if:
+  - `attempt < maxAttempts`;
+  - computed delay `<= maxRetryableDelayMs`.
+- Delay calculation rules:
+  - if Stream provides `Retry-After` / reset information, that server value is preferred even if it is larger than `maxDelayMs`;
+  - `maxDelayMs` only caps fallback delay when server retry timing is missing or malformed;
+  - `maxRetryableDelayMs` decides whether that computed delay is still retryable or should be propagated immediately.
+- If retry is not allowed, the processed rate-limit exception is propagated to the caller.
+
+Core logic: `src/streamRateLimitHandlingProxy/helpers/executeWithRateLimitHandling.ts`
+
+## Configuration
+
+Default behavior is defined in `src/streamRateLimitHandlingProxy/constants.ts`:
+
+- `maxAttempts = 3`
+- `enableCooldown = true`
+- `maxDelayMs = 5000`
+- `maxRetryableDelayMs = 10000`
+
+The same file also contains:
+
+- Redis key prefixes for hard cooldown, soft throttle, and budget cooldown
+- fallback retry values and jitter
+- budget thresholds and cooldown ranges
+- soft-throttle thresholds and delays
+
+Notes:
+
+- `enableCooldown` controls local Redis-based preflight checks and shared cooldown reuse.
+- `maxDelayMs` is a fallback cap, not a hard upper bound for server-provided `Retry-After`.
+- Missing / invalid rate-limit headers do not break the proxy, but they reduce how much shared throttling state can be inferred.
+
+Per-call overrides are passed as the last argument:
+
+```ts
+stream.queryChannels(filters, sort, options, withStreamRateLimitOptions({
+  maxAttempts: 1,
+  maxRetryableDelayMs: 0,
+}));
+```
+
+Argument extraction is implemented in `helpers/splitCallArgsAndOptions.ts`.

package/dist-cjs/index.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./normalization"), exports);
-tslib_1.__exportStar(require("./rateLimits"), exports);
+tslib_1.__exportStar(require("./streamRateLimitHandlingProxy"), exports);
 tslib_1.__exportStar(require("./stream"), exports);
 tslib_1.__exportStar(require("./types"), exports);

package/dist-cjs/streamRateLimitHandlingProxy/constants.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_OPTIONS = exports.SOFT_THROTTLE_DELAY_HIGH_MS = exports.SOFT_THROTTLE_DELAY_MEDIUM_MS = exports.SOFT_THROTTLE_DELAY_LOW_MS = exports.SOFT_THROTTLE_USAGE_HIGH = exports.SOFT_THROTTLE_USAGE_MEDIUM = exports.SOFT_THROTTLE_USAGE_LOW = exports.BUDGET_COOLDOWN_SLEEP_CHUNK_MS = exports.BUDGET_MINIMAL_DELAY_MAX_MS = exports.BUDGET_MINIMAL_DELAY_MIN_MS = exports.BUDGET_RELAXED_DELAY_MAX_MS = exports.BUDGET_RELAXED_DELAY_MIN_MS = exports.BUDGET_RELAXED_USAGE_THRESHOLD = exports.BUDGET_CLEAR_USAGE_THRESHOLD = exports.BUDGET_DELAY_MAX_MS = exports.BUDGET_DELAY_MIN_MS = exports.BUDGET_THRESHOLD = exports.STREAM_BUDGET_COOLDOWN_KEY = exports.STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX = exports.STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY = exports.STREAM_RATE_LIMIT_OPTIONS_MARKER = exports.STREAM_BUDGET_COOLDOWN_KEY_PREFIX = exports.STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX = exports.RETRY_AFTER_BUFFER_MS = exports.DEFAULT_JITTER_MS = exports.DEFAULT_RETRY_AFTER_MS = exports.DEFAULT_MAX_DELAY_MS = exports.STREAM_SYNC_METHOD_NAMES = exports.STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES = exports.STREAM_METHOD_NAMES = exports.STREAM_CHANNEL_RESULT_METHOD_NAMES = exports.CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES = exports.CHANNEL_SYNC_METHOD_NAMES = exports.CHANNEL_METHOD_NAMES = void 0;
+var generatedMethodNames_1 = require("./generatedMethodNames");
+Object.defineProperty(exports, "CHANNEL_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.CHANNEL_METHOD_NAMES; } });
+Object.defineProperty(exports, "CHANNEL_SYNC_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.CHANNEL_SYNC_METHOD_NAMES; } });
+Object.defineProperty(exports, "CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES; } });
+Object.defineProperty(exports, "STREAM_CHANNEL_RESULT_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.STREAM_CHANNEL_RESULT_METHOD_NAMES; } });
+Object.defineProperty(exports, "STREAM_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.STREAM_METHOD_NAMES; } });
+Object.defineProperty(exports, "STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES; } });
+Object.defineProperty(exports, "STREAM_SYNC_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.STREAM_SYNC_METHOD_NAMES; } });
+exports.DEFAULT_MAX_DELAY_MS = 5000;
+exports.DEFAULT_RETRY_AFTER_MS = 10000;
+exports.DEFAULT_JITTER_MS = 150;
+exports.RETRY_AFTER_BUFFER_MS = 1000;
+exports.STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX = 'stream-rate-limit-cooldown:';
+exports.STREAM_BUDGET_COOLDOWN_KEY_PREFIX = 'stream-budget-cooldown:';
+exports.STREAM_RATE_LIMIT_OPTIONS_MARKER = '__xbsRateLimitOptions';
+exports.STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY = 'stream-rate-limit-soft-global';
+exports.STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX = ':meta';
+exports.STREAM_BUDGET_COOLDOWN_KEY = 'stream-budget-global';
+exports.BUDGET_THRESHOLD = 0.8;
+exports.BUDGET_DELAY_MIN_MS = 30000;
+exports.BUDGET_DELAY_MAX_MS = 60000;
+exports.BUDGET_CLEAR_USAGE_THRESHOLD = 0.6;
+exports.BUDGET_RELAXED_USAGE_THRESHOLD = 0.7;
+exports.BUDGET_RELAXED_DELAY_MIN_MS = 5000;
+exports.BUDGET_RELAXED_DELAY_MAX_MS = 10000;
+exports.BUDGET_MINIMAL_DELAY_MIN_MS = 1000;
+exports.BUDGET_MINIMAL_DELAY_MAX_MS = 2000;
+exports.BUDGET_COOLDOWN_SLEEP_CHUNK_MS = 3000;
+exports.SOFT_THROTTLE_USAGE_LOW = 0.7;
+exports.SOFT_THROTTLE_USAGE_MEDIUM = 0.85;
+exports.SOFT_THROTTLE_USAGE_HIGH = 0.95;
+exports.SOFT_THROTTLE_DELAY_LOW_MS = 500;
+exports.SOFT_THROTTLE_DELAY_MEDIUM_MS = 1500;
+exports.SOFT_THROTTLE_DELAY_HIGH_MS = 3000;
+exports.DEFAULT_OPTIONS = {
+    maxAttempts: 3,
+    enableCooldown: true,
+    maxDelayMs: 5000,
+    maxRetryableDelayMs: 10000,
+};

package/dist-cjs/streamRateLimitHandlingProxy/createRateLimitedStreamProxy.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRateLimitedStreamProxy = void 0;
+const constants_1 = require("./constants");
+const executeWithRateLimitHandling_1 = require("./helpers/executeWithRateLimitHandling");
+const isStreamChannelLike_1 = require("./helpers/isStreamChannelLike");
+const registerStreamInterceptors_1 = require("./helpers/registerStreamInterceptors");
+const splitCallArgsAndOptions_1 = require("./helpers/splitCallArgsAndOptions");
+const STREAM_SYNC_METHODS = new Set(constants_1.STREAM_SYNC_METHOD_NAMES);
+const STREAM_CHANNEL_RESULT_METHODS = new Set(constants_1.STREAM_CHANNEL_RESULT_METHOD_NAMES);
+const STREAM_SYNC_CHANNEL_RESULT_METHODS = new Set(constants_1.STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES);
+const CHANNEL_SYNC_METHODS = new Set(constants_1.CHANNEL_SYNC_METHOD_NAMES);
+const CHANNEL_SYNC_PROXY_RESULT_METHODS = new Set(constants_1.CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES);
+function wrapKnownChannelResult(result, dependencies) {
+    if (Array.isArray(result)) {
+        return result.map((item) => wrapKnownChannelResult(item, dependencies));
+    }
+    if (typeof result !== 'object' || result === null) {
+        return result;
+    }
+    return wrapTarget(result, dependencies);
+}
+function normalizeStreamCallResult(result, dependencies, wrapAsChannelResult = false) {
+    if (wrapAsChannelResult) {
+        return wrapKnownChannelResult(result, dependencies);
+    }
+    if (Array.isArray(result)) {
+        return result.map((item) => normalizeStreamCallResult(item, dependencies));
+    }
+    if (!(0, isStreamChannelLike_1.isStreamChannelLike)(result)) {
+        return result;
+    }
+    return wrapTarget(result, dependencies);
+}
+function createRateLimitedMethodWrapper(target, value, operation, dependencies, wrapAsChannelResult) {
+    return async (...args) => {
+        const { callArgs, callOptions } = (0, splitCallArgsAndOptions_1.splitCallArgsAndOptions)(args);
+        const result = await (0, executeWithRateLimitHandling_1.executeWithRateLimitHandling)(() => Reflect.apply(value, target, callArgs), operation, dependencies.context, {
+            ...constants_1.DEFAULT_OPTIONS,
+            ...callOptions,
+        });
+        return normalizeStreamCallResult(result, dependencies, wrapAsChannelResult);
+    };
+}
+function wrapTarget(target, dependencies) {
+    const cachedObject = dependencies.cache.get(target);
+    if (cachedObject) {
+        return cachedObject;
+    }
+    const proxy = new Proxy(target, {
+        get: (originalTarget, property, receiver) => {
+            const value = Reflect.get(originalTarget, property, receiver);
+            if (typeof property !== 'string' || typeof value !== 'function') {
+                return value;
+            }
+            if (STREAM_SYNC_CHANNEL_RESULT_METHODS.has(property)) {
+                return (...args) => {
+                    const { callArgs } = (0, splitCallArgsAndOptions_1.splitCallArgsAndOptions)(args);
+                    const result = Reflect.apply(value, originalTarget, callArgs);
+                    return normalizeStreamCallResult(result, dependencies, true);
+                };
+            }
+            if (CHANNEL_SYNC_PROXY_RESULT_METHODS.has(property)) {
+                return (...args) => {
+                    const { callArgs } = (0, splitCallArgsAndOptions_1.splitCallArgsAndOptions)(args);
+                    const result = Reflect.apply(value, originalTarget, callArgs);
+                    if (typeof result === 'object' && result !== null) {
+                        return wrapTarget(result, dependencies);
+                    }
+                    return result;
+                };
+            }
+            if (STREAM_SYNC_METHODS.has(property) || CHANNEL_SYNC_METHODS.has(property)) {
+                return (...args) => {
+                    const { callArgs } = (0, splitCallArgsAndOptions_1.splitCallArgsAndOptions)(args);
+                    return Reflect.apply(value, originalTarget, callArgs);
+                };
+            }
+            return createRateLimitedMethodWrapper(originalTarget, value, property, dependencies, STREAM_CHANNEL_RESULT_METHODS.has(property));
+        },
+    });
+    dependencies.cache.set(target, proxy);
+    return proxy;
+}
+function createRateLimitedStreamProxy(stream, context) {
+    (0, registerStreamInterceptors_1.registerStreamInterceptors)(stream, context);
+    return wrapTarget(stream, {
+        context,
+        cache: new WeakMap(),
+    });
+}
+exports.createRateLimitedStreamProxy = createRateLimitedStreamProxy;

package/dist-cjs/streamRateLimitHandlingProxy/generatedMethodNames.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES = exports.CHANNEL_SYNC_METHOD_NAMES = exports.CHANNEL_METHOD_NAMES = exports.STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES = exports.STREAM_CHANNEL_RESULT_METHOD_NAMES = exports.STREAM_SYNC_METHOD_NAMES = exports.STREAM_METHOD_NAMES = void 0;
+exports.STREAM_METHOD_NAMES = [
+    '_addChannelConfig',
+    '_buildWSPayload',
+    '_callClientListeners',
+    '_createImport',
+    '_createImportURL',
+    '_deleteUserMessageReference',
+    '_enrichAxiosOptions',
+    '_getConnectionID',
+    '_getImport',
+    '_getToken',
+    '_handleClientEvent',
+    '_handleUserEvent',
+    '_hasConnectionID',
+    '_isUsingServerAuth',
+    '_listImports',
+    '_logApiError',
+    '_logApiRequest',
+    '_logApiResponse',
+    '_muteStatus',
+    '_normalizeDate',
+    '_normalizeExpiration',
+    '_queryFlagReports',
+    '_queryFlags',
+    '_reviewFlagReport',
+    '_sayHi',
+    '_setToken',
+    '_setupConnection',
+    '_setUser',
+    '_startCleaning',
+    '_unblockMessage',
+    '_updateMemberWatcherReferences',
+    '_updateUserMessageReferences',
+    '_updateUserReferences',
+    '_validateAndGetMessageId',
+    'addDevice',
+    'banUser',
+    'channel',
+    'closeConnection',
+    'commitMessage',
+    'connect',
+    'connectAnonymousUser',
+    'connectUser',
+    'createAbortControllerForNextRequest',
+    'createBlockList',
+    'createCampaign',
+    'createChannelType',
+    'createCommand',
+    'createPermission',
+    'createRole',
+    'createSegment',
+    'createToken',
+    'deactivateUser',
+    'deactivateUsers',
+    'delete',
+    'deleteBlockList',
+    'deleteCampaign',
+    'deleteChannels',
+    'deleteChannelType',
+    'deleteCommand',
+    'deleteMessage',
+    'deletePermission',
+    'deletePushProvider',
+    'deleteRole',
+    'deleteSegment',
+    'deleteUser',
+    'deleteUsers',
+    'devToken',
+    'disconnect',
+    'disconnectUser',
+    'dispatchEvent',
+    'doAxiosRequest',
+    'enrichURL',
+    'errorFromResponse',
+    'exportChannel',
+    'exportChannels',
+    'exportUser',
+    'exportUsers',
+    'flagMessage',
+    'flagUser',
+    'get',
+    'getAppSettings',
+    'getAuthType',
+    'getBlockList',
+    'getCallToken',
+    'getChannelById',
+    'getChannelByMembers',
+    'getChannelType',
+    'getCommand',
+    'getDevices',
+    'getExportChannelStatus',
+    'getMessage',
+    'getPermission',
+    'getRateLimits',
+    'getTask',
+    'getUnreadCount',
+    'getUserAgent',
+    'handleEvent',
+    'handleResponse',
+    'hydrateActiveChannels',
+    'listBlockLists',
+    'listChannelTypes',
+    'listCommands',
+    'listPermissions',
+    'listPushProviders',
+    'listRoles',
+    'markAllRead',
+    'markChannelsRead',
+    'muteUser',
+    'off',
+    'on',
+    'openConnection',
+    'partialUpdateMessage',
+    'partialUpdateUser',
+    'partialUpdateUsers',
+    'patch',
+    'pinMessage',
+    'post',
+    'put',
+    'queryBannedUsers',
+    'queryCampaigns',
+    'queryChannels',
+    'queryMessageFlags',
+    'queryRecipients',
+    'querySegments',
+    'queryUsers',
+    'reactivateUser',
+    'reactivateUsers',
+    'recoverState',
+    'removeDevice',
+    'removeShadowBan',
+    'restoreUsers',
+    'resumeCampaign',
+    'revokeTokens',
+    'revokeUsersToken',
+    'revokeUserToken',
+    'scheduleCampaign',
+    'search',
+    'sendFile',
+    'sendUserCustomEvent',
+    'setAnonymousUser',
+    'setBaseURL',
+    'setGuestUser',
+    'setLocalDevice',
+    'setUser',
+    'setUserAgent',
+    'shadowBan',
+    'stopCampaign',
+    'sync',
+    'testCampaign',
+    'testPushSettings',
+    'testSQSSettings',
+    'translateMessage',
+    'unbanUser',
+    'unblockMessage',
+    'unflagMessage',
+    'unflagUser',
+    'unmuteUser',
+    'unpinMessage',
+    'updateAppSettings',
+    'updateBlockList',
+    'updateCampaign',
+    'updateChannelType',
+    'updateCommand',
+    'updateMessage',
+    'updatePermission',
+    'updateSegment',
+    'updateUser',
+    'updateUsers',
+    'upsertPushProvider',
+    'upsertUser',
+    'upsertUsers',
+    'userMuteStatus',
+    'verifyWebhook',
+];
+exports.STREAM_SYNC_METHOD_NAMES = [
+    '_addChannelConfig',
+    '_buildWSPayload',
+    '_callClientListeners',
+    '_deleteUserMessageReference',
+    '_enrichAxiosOptions',
+    '_getConnectionID',
+    '_getToken',
+    '_handleClientEvent',
+    '_handleUserEvent',
+    '_hasConnectionID',
+    '_isUsingServerAuth',
+    '_logApiError',
+    '_logApiRequest',
+    '_logApiResponse',
+    '_muteStatus',
+    '_normalizeDate',
+    '_normalizeExpiration',
+    '_sayHi',
+    '_setUser',
+    '_startCleaning',
+    '_updateMemberWatcherReferences',
+    '_updateUserMessageReferences',
+    '_updateUserReferences',
+    '_validateAndGetMessageId',
+    'createAbortControllerForNextRequest',
+    'createToken',
+    'devToken',
+    'dispatchEvent',
+    'errorFromResponse',
+    'getAuthType',
+    'getUserAgent',
+    'handleEvent',
+    'handleResponse',
+    'off',
+    'on',
+    'setBaseURL',
+    'setLocalDevice',
+    'setUserAgent',
+    'userMuteStatus',
+    'verifyWebhook',
+];
+exports.STREAM_CHANNEL_RESULT_METHOD_NAMES = [
+    'channel',
+    'getChannelById',
+    'getChannelByMembers',
+    'hydrateActiveChannels',
+    'queryChannels',
+];
+exports.STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES = [
+    'channel',
+    'getChannelById',
+    'getChannelByMembers',
+    'hydrateActiveChannels',
+];
+exports.CHANNEL_METHOD_NAMES = [
+    '_callChannelListeners',
+    '_channelURL',
+    '_checkInitialized',
+    '_countMessageAsUnread',
+    '_disconnect',
+    '_extendEventWithOwnReactions',
+    '_handleChannelEvent',
+    '_initializeState',
+    '_update',
+    'acceptInvite',
+    'addMembers',
+    'addModerators',
+    'assignRoles',
+    'banUser',
+    'clean',
+    'countUnread',
+    'countUnreadMentions',
+    'create',
+    'createCall',
+    'delete',
+    'deleteFile',
+    'deleteImage',
+    'deleteReaction',
+    'demoteModerators',
+    'disableSlowMode',
+    'enableSlowMode',
+    'getClient',
+    'getConfig',
+    'getMessagesById',
+    'getPinnedMessages',
+    'getReactions',
+    'getReplies',
+    'hide',
+    'inviteMembers',
+    'keystroke',
+    'lastMessage',
+    'lastRead',
+    'markRead',
+    'markUnread',
+    'mute',
+    'muteStatus',
+    'off',
+    'on',
+    'query',
+    'queryMembers',
+    'rejectInvite',
+    'removeMembers',
+    'removeShadowBan',
+    'search',
+    'sendAction',
+    'sendEvent',
+    'sendFile',
+    'sendImage',
+    'sendMessage',
+    'sendReaction',
+    'shadowBan',
+    'show',
+    'stopTyping',
+    'stopWatching',
+    'truncate',
+    'unbanUser',
+    'unmute',
+    'update',
+    'updatePartial',
+    'watch',
+];
+exports.CHANNEL_SYNC_METHOD_NAMES = [
+    '_callChannelListeners',
+    '_channelURL',
+    '_checkInitialized',
+    '_countMessageAsUnread',
+    '_disconnect',
+    '_extendEventWithOwnReactions',
+    '_handleChannelEvent',
+    '_initializeState',
+    'clean',
+    'countUnread',
+    'countUnreadMentions',
+    'getConfig',
+    'lastMessage',
+    'lastRead',
+    'muteStatus',
+    'off',
+    'on',
+];
+exports.CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES = ['getClient'];