@amityco/ts-sdk 0.0.1-beta.37 → 0.0.1-beta.39

package/dist/index.cjs.js

@@ -7,7 +7,6 @@ var AsyncStorage = require('@react-native-async-storage/async-storage');
 var mitt = require('mitt');
 var debug = require('debug');
 var axios = require('axios');
-var qs = require('qs');
 var HttpAgent = require('agentkeepalive');
 var io = require('socket.io-client');
 var nativeIdGenerator = require('react-native-uuid');
@@ -18,7 +17,6 @@ var AsyncStorage__default = /*#__PURE__*/_interopDefaultLegacy(AsyncStorage);
 var mitt__default = /*#__PURE__*/_interopDefaultLegacy(mitt);
 var debug__default = /*#__PURE__*/_interopDefaultLegacy(debug);
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
-var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
 var HttpAgent__default = /*#__PURE__*/_interopDefaultLegacy(HttpAgent);
 var io__default = /*#__PURE__*/_interopDefaultLegacy(io);
 var nativeIdGenerator__default = /*#__PURE__*/_interopDefaultLegacy(nativeIdGenerator);
@@ -179,14 +177,14 @@ const partialMatch = (predicate, candidate) => {
 const checkIfShouldGoesToTombstone = (errorCode) => [400400 /* Amity.ServerError.ITEM_NOT_FOUND */, 400300 /* Amity.ServerError.FORBIDDEN */].includes(errorCode);
 
 /**
- * Type guard to find if the a given decoded backend token uses "skip/limit" pagination style
+ * Type guard to find if the a given decoded backend token uses "skip" pagination style
  *
  * @param json any json object as extracted from the backend
  * @returns success boolean if the token has either "skip" or "limit" props
  *
  * @hidden
  */
-const isSkipLimit = (json) => ['skip', 'limit'].some(prop => prop in json);
+const isSkip = (json) => ['skip'].some(prop => prop in json);
 /**
  * Type guard to find if the a given decoded backend token uses "after/before" pagination style
  *
@@ -286,7 +284,7 @@ const toPage = (token) => {
         return undefined;
     // don't try catch, let it throw
     const json = JSON.parse(jsBase64.decode(token));
-    if (isSkipLimit(json)) {
+    if (isSkip(json)) {
         return {
             after: json.skip,
             limit: json.limit,
@@ -513,6 +511,7 @@ const idResolvers = {
     stream: ({ streamId }) => streamId,
     follow: ({ from, to }) => `${from}#${to}`,
     followCount: ({ userId }) => userId,
+    feed: ({ targetId, feedId }) => `${targetId}#${feedId}`,
 };
 /**
  * Retrieve the id resolver matching a domain name
@@ -550,6 +549,7 @@ const CRITERIAS = {
     stream: ['streamId'],
     follow: ['from', 'to'],
     followCount: ['userId', 'followerCount'],
+    feed: ['feedId', 'feedType'],
 };
 /** @hidden */
 const hasKeys = (object, needles) => {
@@ -610,6 +610,7 @@ const PAYLOAD2MODEL = {
     videoStreamings: 'stream',
     follows: 'follow',
     followCounts: 'followCount',
+    feeds: 'feed',
 };
 /** hidden */
 const hasUpdates = (prevData, nextData) => {
@@ -1076,10 +1077,36 @@ const filterByChannelMembership = (collection, membership, userId) => {
             'get',
             channelUserCacheKey,
         ])) === null || _a === void 0 ? void 0 : _a.data;
-        if (membership === 'member' && channelUser && channelUser.membership !== 'none') {
-            return true;
+        if (membership === 'member') {
+            return channelUser && channelUser.membership !== 'none';
         }
-        return membership === 'notMember' && (!channelUser || channelUser.membership === 'none');
+        // only membership value remainging is 'notMember'
+        return !channelUser || channelUser.membership === 'none';
+    });
+};
+/**
+ * Filter a channel collection by membership of the userId
+ *
+ * @param collection the channel collection to filter
+ * @param feedType to be filtered by
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+const filterByFeedType = (collection, feedType) => {
+    /*
+     * It is possible that the targetId & feedId are the same for most of the posts
+     * But since cache is in-memory, i've avoided memoizing, to avoid premature
+     * optimization. Can be revisited if performance issues arise
+     */
+    return collection.filter(({ targetId, feedId }) => {
+        var _a;
+        const feed = (_a = pullFromCache([
+            'feed',
+            'get',
+            getResolver('feed')({ targetId, feedId }),
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        return feed && feed.feedType === feedType;
     });
 };
 
@@ -1094,6 +1121,14 @@ const sortByDisplayName = ({ displayName: a }, { displayName: b }) => {
         return 0;
     return a < b ? -1 : 1;
 };
+/**
+ * Alphabetic sorting of objects having a name
+ */
+const sortByName = ({ name: a }, { name: b }) => {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+};
 /**
  * Sorting a collection by their apparition order (oldest first)
  */
@@ -1397,13 +1432,6 @@ const unwrapPayload = (response) => {
     return undefined;
 };
 
-/**
- * Axios param serializer (for querystring)
- * @hidden
- */
-const stringify = (params) => {
-    return qs__default["default"].stringify(params, { arrayFormat: 'brackets' });
-};
 /**
  * Creates a pre-configured axios instance
  *
@@ -1424,7 +1452,14 @@ const createHttpTransport = (endpoint) => {
         baseURL: endpoint,
         httpAgent: new HttpAgent__default["default"](options),
         httpsAgent: new HttpAgent.HttpsAgent(options),
-        paramsSerializer: stringify,
+        /*
+         * If paramSerializer is required, use the serialize option to stringify
+         * params. The encode option will pass complex params as string only whereas
+         * the serialize option will pass params in the format Record<string, any>
+         *
+         * For more details:
+         * https://github.com/axios/axios#request-config
+         */
     });
     instance.interceptors.request.use(config => {
         var _a;
@@ -1438,10 +1473,8 @@ const createHttpTransport = (endpoint) => {
         return config;
     });
     instance.interceptors.response.use(response => response, error => {
-        var _a;
+        var _a, _b;
         const { response } = error;
-        // eslint-disable-next-line no-console
-        console.error((_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : error);
         // handle unauthorized request
         if (response.data.code === 400100 /* Amity.ServerError.UNAUTHORIZED */) {
             fireEvent('tokenTerminated', "terminated" /* Amity.SessionStates.TERMINATED */);
@@ -1451,8 +1484,15 @@ const createHttpTransport = (endpoint) => {
             fireEvent('tokenExpired', "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */);
             throw new ASCError('Token expired', 800403 /* Amity.ClientError.TOKEN_EXPIRED */, "fatal" /* Amity.ErrorLevel.FATAL */);
         }
-        if (response === null || response === void 0 ? void 0 : response.data)
-            unwrapPayload(response.data);
+        // if it's an error with status in the response payload,
+        // then it's an expected error.
+        if ((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.status) {
+            unwrapPayload(response === null || response === void 0 ? void 0 : response.data);
+        }
+        // unexpected error.
+        else {
+            throw new Error((_b = response === null || response === void 0 ? void 0 : response.data) !== null && _b !== void 0 ? _b : error);
+        }
     });
     return instance;
 };
@@ -20809,7 +20849,7 @@ const connectClient = async (params, sessionHandler, config) => {
         setSessionState(state);
         disconnectClient();
         subscriptions.forEach(fn => fn());
-    }), onUserDeleted(() => null));
+    }));
     return client.ws.connected;
 };
 
@@ -20892,7 +20932,8 @@ const isExpired = (expiresAt) => Date.now() > Date.parse(expiresAt) - COMPENSATE
  *
  * @category private
  */
-const isAboutToExpire = (expiresAt, issuedAt) => {
+const isAboutToExpire = (params) => {
+    const { expiresAt, issuedAt } = params;
     const expires = Date.parse(expiresAt);
     const issued = Date.parse(issuedAt);
     const now = Date.now();
@@ -20927,7 +20968,7 @@ const accessTokenExpiryWatcher = (expiresAt, issuedAt, sessionHandler) => {
             scheduleTask(() => sessionHandler.sessionWillRenewAccessToken(renewal()));
             return;
         }
-        if (isAboutToExpire(issuedAt, expiresAt)) {
+        if (isAboutToExpire({ expiresAt, issuedAt })) {
             sessionHandler.sessionWillRenewAccessToken(renewal());
         }
     }, ACCESS_TOKEN_WATCHER_INTERVAL);
@@ -21398,6 +21439,58 @@ const onUserUnflagged = (callback) => createUserEventSubscriber('user.unflagged'
  */
 const onUserFlagCleared = (callback) => createUserEventSubscriber('user.flagCleared', callback);
 
+const liveObject = (id, callback, key, fetcher, eventHandlers) => {
+    const { cache } = getActiveClient();
+    if (!cache) {
+        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+    }
+    let model;
+    let isUnsyncedModel = false; // for messages
+    const disposers = [];
+    const dispatcher = (data) => {
+        model = data.data;
+        callback(data);
+    };
+    const realtimeRouter = (eventModel) => {
+        if (id !== eventModel[key]) {
+            return;
+        }
+        if (model && !hasUpdates(model, eventModel)) {
+            return;
+        }
+        dispatcher({ loading: false, data: eventModel, origin: 'event' });
+    };
+    const onFetch = () => {
+        // @ts-ignore
+        const query = createQuery(fetcher, id, true);
+        runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+                dispatcher({
+                    // @ts-ignore
+                    data,
+                    origin,
+                    loading: false,
+                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
+                });
+                isUnsyncedModel = true;
+                disposers.forEach(fn => fn());
+            }
+            else if (!isUnsyncedModel) {
+                // @ts-ignore
+                dispatcher({ loading, data, origin, error });
+            }
+            if (error) {
+                disposers.forEach(fn => fn());
+            }
+        });
+    };
+    disposers.push(...eventHandlers.map(fn => fn(realtimeRouter)));
+    onFetch();
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
 /**
  * ```js
  * import { onUserFetched } from '@amityco/ts-sdk'
@@ -21435,40 +21528,107 @@ const onUserFetched = (callback) => createUserEventSubscriber('user.fetched', ca
  * @category Message Live Object
  */
 const liveUser = (userId, callback) => {
+    return liveObject(userId, callback, 'userId', getUser, [
+        onUserFetched,
+        onUserUpdated,
+        onUserDeleted,
+        onUserFlagged,
+        onUserUnflagged,
+        onUserFlagCleared,
+    ]);
+};
+
+/**
+ * ```js
+ * import { liveUsers } from '@amityco/ts-sdk'
+ *
+ * let users = []
+ * const unsub = liveUsers({}, response => merge(users, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.User}s
+ *
+ * @param params for querying users
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the users
+ *
+ * @category Category Live Collection
+ */
+const liveUsers = (params, callback, config) => {
     const { log, cache } = getActiveClient();
-    const timestamp = Date.now();
-    log(`liveUser(tmpid: ${timestamp}) > listen`);
     if (!cache) {
-        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+        console.log(ENABLE_CACHE_MESSAGE);
     }
-    let user;
+    const timestamp = Date.now();
+    log(`liveUsers(tmpid: ${timestamp}) > listen`);
+    const { limit: queryLimit } = params, queryParams = __rest(params, ["limit"]);
+    const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
+    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
     const disposers = [];
-    const dispatcher = (data) => {
-        user = data.data;
-        callback(data);
-    };
-    const realtimeRouter = (eventUser) => {
-        if (userId !== eventUser.userId) {
-            return;
+    const cacheKey = ['user', 'collection', {}];
+    const responder = (data) => {
+        var _a, _b;
+        let users = (_a = data.data
+            .map(userId => pullFromCache(['user', 'get', userId]))
+            .filter(Boolean)
+            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+        users = filterByPropEquality(users, 'displayName', params.displayName);
+        switch (params.sortBy) {
+            case 'firstCreated':
+                users = users.sort(sortByFirstCreated);
+                break;
+            case 'lastCreated':
+                users = users.sort(sortByLastCreated);
+                break;
+            default:
+                users = users
+                    // this needs to be aligned with the backend data type
+                    .map(u => (u.displayName ? u : Object.assign(Object.assign({}, u), { displayName: '' })))
+                    // @ts-ignore
+                    .sort(sortByDisplayName);
         }
-        if (user && !hasUpdates(user, eventUser)) {
+        callback({
+            onNextPage: onFetch,
+            data: users,
+            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (_) => (user) => {
+        var _a;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
             return;
-        }
-        dispatcher({ loading: false, data: eventUser, origin: 'event' });
+        collection.data = [...new Set([user.userId, ...collection.data])];
+        pushToCache(cacheKey, collection);
+        responder(collection);
     };
     const onFetch = () => {
-        const query = createQuery(getUser, userId, true);
-        runQuery(query, ({ loading, data, error, origin }) => {
-            dispatcher({ loading, data, origin, error });
-            if (error) {
-                disposers.forEach(fn => fn());
+        var _a, _b, _c;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const users = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        if (users.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
+            return;
+        const query = createQuery(queryUsers, Object.assign(Object.assign({}, queryParams), { page: (_c = collection === null || collection === void 0 ? void 0 : collection.params.page) !== null && _c !== void 0 ? _c : { limit } }));
+        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
+            const data = {
+                loading,
+                error,
+                params: { page },
+                data: users,
+            };
+            if (result) {
+                data.data = [...new Set([...users, ...result.map(getResolver('user'))])];
             }
-        });
+            pushToCache(cacheKey, data);
+            responder(data);
+        }, queryOptions(policy));
     };
-    disposers.push(onUserFetched(realtimeRouter), onUserUpdated(realtimeRouter), onUserDeleted(realtimeRouter), onUserFlagged(realtimeRouter), onUserUnflagged(realtimeRouter), onUserFlagCleared(realtimeRouter));
+    disposers.push(onUserUpdated(realtimeRouter()), onUserDeleted(realtimeRouter()), onUserFlagged(realtimeRouter()), onUserUnflagged(realtimeRouter()), onUserFlagCleared(realtimeRouter()));
     onFetch();
     return () => {
-        log(`liveUser(tmpid: ${timestamp}) > dispose`);
+        log(`liveUsers(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
     };
 };
@@ -21594,7 +21754,7 @@ const createFile = async (formData, onProgress) => {
         : { 'content-type': 'multipart/form-data' };
     const { data } = await client.http.post('/api/v4/files', formData, {
         headers,
-        onUploadProgress({ loaded, total }) {
+        onUploadProgress({ loaded, total = 100 }) {
             onProgress && onProgress(Math.round((loaded * 100) / total));
         },
     });
@@ -21673,7 +21833,7 @@ const createVideo = async (formData, feedType, onProgress) => {
         : { 'content-type': 'multipart/form-data' };
     const { data } = await client.http.post('/api/v4/videos', formData, {
         headers,
-        onUploadProgress({ loaded, total }) {
+        onUploadProgress({ loaded, total = 100 }) {
             onProgress && onProgress(Math.round((loaded * 100) / total));
         },
     });
@@ -21714,7 +21874,7 @@ const createImage = async (formData, onProgress) => {
         : { 'content-type': 'multipart/form-data' };
     const { data } = await client.http.post('/api/v4/images', formData, {
         headers,
-        onUploadProgress({ loaded, total }) {
+        onUploadProgress({ loaded, total = 100 }) {
             onProgress && onProgress(Math.round((loaded * 100) / total));
         },
     });
@@ -22154,8 +22314,8 @@ const queryMessages = async (query) => {
         pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });
     }
     fireEvent('local.message.fetched', { messages });
-    const nextPage = toPage(paging.next);
-    const prevPage = toPage(paging.previous);
+    const nextPage = toPageRaw(paging.next);
+    const prevPage = toPageRaw(paging.previous);
     return { data: messages, cachedAt, prevPage, nextPage };
 };
 /**
@@ -22186,8 +22346,8 @@ queryMessages.locally = (query) => {
         .map(messageId => pullFromCache(['message', 'get', messageId]))
         .filter(Boolean)
         .map(({ data }) => data);
-    const prevPage = toPage(data === null || data === void 0 ? void 0 : data.paging.previous);
-    const nextPage = toPage(data === null || data === void 0 ? void 0 : data.paging.next);
+    const prevPage = toPageRaw(data === null || data === void 0 ? void 0 : data.paging.previous);
+    const nextPage = toPageRaw(data === null || data === void 0 ? void 0 : data.paging.next);
     return messages.length === ((_b = data === null || data === void 0 ? void 0 : data.messages) === null || _b === void 0 ? void 0 : _b.length)
         ? { data: messages, cachedAt, prevPage, nextPage }
         : undefined;
@@ -23693,6 +23853,7 @@ getComments.locally = (commentIds) => {
 const getComment = async (commentId) => {
     const client = getActiveClient();
     client.log('comment/getComment', commentId);
+    isInTombstone('comment', commentId);
     let data;
     try {
         // API-FIX: endpoint should not be /list, parameters should be querystring.
@@ -23700,8 +23861,8 @@ const getComment = async (commentId) => {
         data = response.data;
     }
     catch (error) {
-        if ((error === null || error === void 0 ? void 0 : error.code) === 400400 /* Amity.ServerError.ITEM_NOT_FOUND */) {
-            dropFromCache(['comment', 'get', commentId], true);
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('comment', commentId);
         }
         throw error;
     }
@@ -23835,9 +23996,7 @@ const deleteComment = async (commentId, permanent = false) => {
     fireEvent('post.updated', { posts: [post.data] });
     fireEvent('comment.deleted', { comments: [deleted] });
     if (permanent) {
-        setTimeout(() => {
-            dropFromCache(['comment', 'get', commentId], true);
-        }, 0);
+        scheduleTask(() => pushToTombstone('comment', commentId));
     }
     else {
         upsertInCache(['comment', 'get', commentId], { isDeleted: true });
@@ -24833,13 +24992,7 @@ const createReport = async (referenceType, referenceId) => {
     const { data } = await client.http.post(getAPIUrl());
     if (client.cache)
         ingestInCache(referenceType === 'message' ? prepareMessagePayload(data) : data);
-    if (referenceType === 'message') {
-        fireEvent('message.flagged', data);
-    }
-    else {
-        // @ts-ignore
-        fireEvent(`${referenceType}.flagged`, data);
-    }
+    fireEvent(`${referenceType}.flagged`, data);
     return !!data;
 };
 
@@ -24872,13 +25025,8 @@ const deleteReport = async (referenceType, referenceId) => {
     const { data } = await client.http.delete(getAPIUrl());
     if (client.cache)
         ingestInCache(referenceType === 'message' ? prepareMessagePayload(data) : data);
-    if (referenceType === 'message') {
-        fireEvent('message.unflagged', data);
-    }
-    else {
-        // @ts-ignore
-        fireEvent(`${referenceType}.unflagged`, data);
-    }
+    // @ts-ignore
+    fireEvent(`${referenceType}.unflagged`, data);
     return !!data;
 };
 
@@ -26260,55 +26408,13 @@ const onMessageReactionRemoved = (callback) => {
  * @category Message Live Object
  */
 const liveChannel = (channelId, callback) => {
-    const { log, cache } = getActiveClient();
-    const timestamp = Date.now();
-    log(`liveChannel(tmpid: ${timestamp}) > listen`);
-    if (!cache) {
-        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-    }
-    let channel;
-    let isUnsyncedObject = false;
-    const disposers = [];
-    const dispatcher = (data) => {
-        channel = data.data;
-        callback(data);
-    };
-    const realtimeRouter = (eventChannel) => {
-        if (channelId !== eventChannel.channelId) {
-            return;
-        }
-        if (channel && !hasUpdates(channel, eventChannel)) {
-            return;
-        }
-        dispatcher({ loading: false, data: eventChannel, origin: 'event' });
-    };
-    const onFetch = () => {
-        const query = createQuery(getChannel, channelId);
-        runQuery(query, ({ loading, data, error, origin, cachedAt }) => {
-            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
-                dispatcher({
-                    data,
-                    origin,
-                    loading: false,
-                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
-                });
-                isUnsyncedObject = true;
-                disposers.forEach(fn => fn());
-            }
-            else if (!isUnsyncedObject) {
-                dispatcher({ loading, data, origin, error });
-            }
-            if (error) {
-                disposers.forEach(fn => fn());
-            }
-        });
-    };
-    disposers.push(onChannelUpdated(realtimeRouter), onChannelDeleted(realtimeRouter), onChannelJoined(realtimeRouter), onChannelMuted(realtimeRouter), onMessageCreated(() => null));
-    onFetch();
-    return () => {
-        log(`liveChannel(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
+    return liveObject(channelId, callback, 'channelId', getChannel, [
+        onChannelUpdated,
+        onChannelDeleted,
+        onChannelJoined,
+        onChannelMuted,
+        () => onMessageCreated(() => null), // watch unread count
+    ]);
 };
 
 /**
@@ -26362,22 +26468,29 @@ const liveChannels = (params, callback, config) => {
         if (params.membership && userId) {
             channels = filterByChannelMembership(channels, params.membership, userId);
         }
-        const sortBy = params.sortBy || 'lastCreated';
-        if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
-            channels = channels.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
-        }
-        /*
-         * The server returns channels with empty | null displayName's first before
-         * returning sorted list of channels with displayNames
-         *
-         * This section needs to be updated as displayNames can be null as well
-         */
-        if (sortBy === 'displayName') {
-            channels = channels
-                // this needs to be aligned with the backend data type
-                .map(c => (c.displayName ? c : Object.assign(Object.assign({}, c), { displayName: '' })))
-                // @ts-ignore
-                .sort(sortByDisplayName);
+        switch (params.sortBy) {
+            case 'firstCreated':
+                channels = channels.sort(sortByFirstCreated);
+                break;
+            case 'lastCreated':
+                channels = channels.sort(sortByLastCreated);
+                break;
+            case 'displayName':
+                /*
+                 * The server returns channels with empty | null displayName's first before
+                 * returning sorted list of channels with displayNames
+                 *
+                 * This section needs to be updated as displayNames can be null as well
+                 */
+                channels = channels
+                    // this needs to be aligned with the backend data type
+                    .map(c => (c.displayName ? c : Object.assign(Object.assign({}, c), { displayName: '' })))
+                    // @ts-ignore
+                    .sort(sortByDisplayName);
+                break;
+            default:
+                channels = channels.sort(sortByLastActivity);
+                break;
         }
         callback({
             onNextPage: onFetch,
@@ -26387,17 +26500,12 @@ const liveChannels = (params, callback, config) => {
             error: data.error,
         });
     };
-    const realtimeRouter = (action) => (channel) => {
+    const realtimeRouter = (_) => (channel) => {
         var _a;
         const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
         if (!collection)
             return;
-        if (action === 'onDelete' && params.isDeleted === false) {
-            collection.data = collection.data.filter(c => c !== channel.channelId);
-        }
-        else {
-            collection.data = [...new Set([channel.channelId, ...collection.data])];
-        }
+        collection.data = [...new Set([channel.channelId, ...collection.data])];
         pushToCache(cacheKey, collection);
         responder(collection);
     };
@@ -26422,7 +26530,7 @@ const liveChannels = (params, callback, config) => {
             responder(data);
         }, queryOptions(policy));
     };
-    disposers.push(onChannelCreated(realtimeRouter('onCreate')), onChannelDeleted(realtimeRouter('onDelete')), onChannelUpdated(realtimeRouter('onUpdate')), onChannelMuted(realtimeRouter('onMute')), onChannelJoined(realtimeRouter('onJoin')), onChannelLeft(realtimeRouter('onLeft')), onChannelMemberAdded(realtimeRouter('onMemberAdded')), onChannelMemberRemoved(realtimeRouter('onMemberRemoved')), onMessageCreated(() => null));
+    disposers.push(onChannelCreated(realtimeRouter()), onChannelDeleted(realtimeRouter()), onChannelUpdated(realtimeRouter()), onChannelMuted(realtimeRouter()), onChannelJoined(realtimeRouter()), onChannelLeft(realtimeRouter()), onChannelMemberAdded(realtimeRouter()), onChannelMemberRemoved(realtimeRouter()), onMessageCreated(() => null));
     onFetch();
     return () => {
         log(`liveChannels(tmpid: ${timestamp}) > dispose`);
@@ -26969,42 +27077,11 @@ const onSubChannelFetched = (callback) => {
  * @category SubChannel Live Object
  */
 const liveSubChannel = (subChannelId, callback) => {
-    const { log, cache } = getActiveClient();
-    const timestamp = Date.now();
-    log(`liveSubChannel(tmpid: ${timestamp}) > listen`);
-    if (!cache) {
-        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-    }
-    let subChannel;
-    const disposers = [];
-    const dispatcher = (data) => {
-        subChannel = data.data;
-        callback(data);
-    };
-    const realtimeRouter = (eventSubChannel) => {
-        if (subChannelId !== eventSubChannel.subChannelId) {
-            return;
-        }
-        if (subChannel && !hasUpdates(subChannel, eventSubChannel)) {
-            return;
-        }
-        dispatcher({ loading: false, data: eventSubChannel, origin: 'event' });
-    };
-    const onFetch = () => {
-        const query = createQuery(getSubChannel, subChannelId);
-        runQuery(query, ({ error, data, loading, origin }) => {
-            dispatcher({ error, data, loading, origin });
-            if (error) {
-                disposers.forEach(fn => fn());
-            }
-        });
-    };
-    disposers.push(onSubChannelFetched(realtimeRouter), onSubChannelUpdated(realtimeRouter), onSubChannelDeleted(realtimeRouter));
-    onFetch();
-    return () => {
-        log(`liveSubChannel(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
+    return liveObject(subChannelId, callback, 'subChannelId', getSubChannel, [
+        onSubChannelFetched,
+        onSubChannelUpdated,
+        onSubChannelDeleted,
+    ]);
 };
 
 /**
@@ -27135,55 +27212,16 @@ const onMessageFetched = (callback) => {
  * @category Message Live Object
  */
 const liveMessage = (messageId, callback) => {
-    const { log, cache } = getActiveClient();
-    const timestamp = Date.now();
-    log(`liveMessage(tmpid: ${timestamp}) > listen`);
-    if (!cache) {
-        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-    }
-    let message;
-    let isUnsyncedObject = false;
-    const disposers = [];
-    const dispatcher = (data) => {
-        message = data.data;
-        callback(data);
-    };
-    const realtimeRouter = (eventMessage) => {
-        if (messageId !== eventMessage.messageId) {
-            return;
-        }
-        if (message && !hasUpdates(message, eventMessage)) {
-            return;
-        }
-        dispatcher({ loading: false, data: eventMessage, origin: 'event' });
-    };
-    const onFetch = () => {
-        const query = createQuery(getMessage, messageId, true);
-        runQuery(query, ({ loading, data, error, origin, cachedAt }) => {
-            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
-                dispatcher({
-                    data,
-                    origin,
-                    loading: false,
-                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
-                });
-                isUnsyncedObject = true;
-                disposers.forEach(fn => fn());
-            }
-            else if (!isUnsyncedObject) {
-                dispatcher({ loading, data, origin, error });
-            }
-            if (error) {
-                disposers.forEach(fn => fn());
-            }
-        });
-    };
-    disposers.push(onMessageFetched(realtimeRouter), onMessageUpdated(realtimeRouter), onMessageDeleted(realtimeRouter), onMessageFlagged(realtimeRouter), onMessageUnflagged(realtimeRouter), onMessageFlagCleared(realtimeRouter), onMessageReactionAdded(realtimeRouter), onMessageReactionRemoved(realtimeRouter));
-    onFetch();
-    return () => {
-        log(`liveMessage(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
+    return liveObject(messageId, callback, 'messageId', getMessage, [
+        onMessageFetched,
+        onMessageUpdated,
+        onMessageDeleted,
+        onMessageFlagged,
+        onMessageUnflagged,
+        onMessageFlagCleared,
+        onMessageReactionAdded,
+        onMessageReactionRemoved,
+    ]);
 };
 
 /**
@@ -27384,6 +27422,30 @@ const createCommunityEventSubscriber = (event, callback) => {
     };
     return createEventSubscriber(client, event, event, filter);
 };
+/*
+ * verifies membership status
+ */
+function isMember(membership) {
+    return membership !== 'none';
+}
+/*
+ * checks if currently logged in user is part of the community
+ */
+function isCurrentUserPartOfCommunity(c, m) {
+    const { userId } = getActiveUser();
+    return c.communityId === m.communityId && m.userId === userId;
+}
+/*
+ * For mqtt events server will not send user specific data as it's broadcasted
+ * to multiple users. Althought this can be calculated, it's not scalable. Hence
+ * the client SDK needs to calculate this info
+ */
+function updateMembershipStatus(communities, communityUsers) {
+    return communities.map(c => {
+        const isJoined = communityUsers.some(m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership));
+        return Object.assign(Object.assign({}, c), { isJoined });
+    });
+}
 function hasPermission(member, payload, permission) {
     if (member.permissions.some(x => x === permission)) {
         return true;
@@ -27414,7 +27476,15 @@ const createCommunityMemberEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
         const communityPayload = unpackCommunityPayload(payload);
+        const { communities } = communityPayload;
         const preparedPayload = prepareMembershipPayload(communityPayload, 'communityUsers');
+        const { communityUsers } = preparedPayload;
+        /*
+         * community.isJoined is not part of the communityMembership payload, and needs
+         * to be calculated based on the communityMembership value
+         */
+        const communitiesWithMembership = updateMembershipStatus(communities, communityUsers);
+        preparedPayload.communities = communitiesWithMembership;
         if (!client.cache) {
             // TODO: here we are missing specific properties here!
             callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
@@ -27556,6 +27626,23 @@ const onCommunityUserAdded = (callback) => createCommunityMemberEventSubscriber(
  */
 const onCommunityUserRemoved = (callback) => createCommunityMemberEventSubscriber('community.userRemoved', callback);
 
+/**
+ * ```js
+ * import { onCommunityUserChanged } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserChanged((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user has been added or removed from a {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+const onCommunityUserChanged = (callback) => createCommunityMemberEventSubscriber('community.userChanged', callback);
+
 /**
  * ```js
  * import { onCommunityUserBanned } from '@amityco/ts-sdk'
@@ -27634,6 +27721,122 @@ const observeCommunity = (communityId, callback) => {
     };
 };
 
+/**
+ * ```js
+ * import { liveCommunities } from '@amityco/ts-sdk'
+ *
+ * let communities = []
+ * const unsub = liveCommunities({
+ *   displayName: Amity.Community['displayName'],
+ * }, response => merge(communities, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Community}s
+ *
+ * @param params for querying communities
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the communities
+ *
+ * @category Community Live Collection
+ */
+const liveCommunities = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveCommunities(tmpid: ${timestamp}) > listen`);
+    const { limit: queryLimit } = params, queryParams = __rest(params, ["limit"]);
+    const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
+    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
+    const disposers = [];
+    const cacheKey = ['community', 'collection', {}];
+    const responder = (data) => {
+        var _a, _b;
+        let communities = (_a = data.data
+            .map(communityId => pullFromCache(['community', 'get', communityId]))
+            .filter(Boolean)
+            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+        communities = filterByPropEquality(communities, 'isDeleted', params.isDeleted);
+        communities = filterByPropEquality(communities, 'displayName', params.displayName);
+        if (params.categoryId) {
+            communities = communities.filter(c => { var _a; return (_a = c.categoryIds) === null || _a === void 0 ? void 0 : _a.includes(params.categoryId); });
+        }
+        if (params.tags) {
+            communities = communities.filter(c => { var _a; return (_a = c.tags) === null || _a === void 0 ? void 0 : _a.some(t => { var _a; return (_a = params.tags) === null || _a === void 0 ? void 0 : _a.includes(t); }); });
+        }
+        if (params.membership === 'member') {
+            communities = filterByPropEquality(communities, 'isJoined', true);
+        }
+        if (params.membership === 'notMember') {
+            communities = filterByPropEquality(communities, 'isJoined', false);
+        }
+        const sortBy = params.sortBy || 'lastCreated';
+        if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
+            communities = communities.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+        }
+        /*
+         * The server returns communities with empty | null displayName's first before
+         * returning sorted list of communities with displayNames
+         *
+         * This section needs to be updated as displayNames can be null as well
+         */
+        if (sortBy === 'displayName') {
+            communities = communities
+                // this needs to be aligned with the backend data type
+                .map(c => (c.displayName ? c : Object.assign(Object.assign({}, c), { displayName: '' })))
+                // @ts-ignore
+                .sort(sortByDisplayName);
+        }
+        callback({
+            onNextPage: onFetch,
+            data: communities,
+            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (_) => (community) => {
+        var _a;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        /*
+         * Simply update collection and let responder decide what to do with data
+         */
+        collection.data = [...new Set([community.communityId, ...collection.data])];
+        pushToCache(cacheKey, collection);
+        responder(collection);
+    };
+    const onFetch = () => {
+        var _a, _b, _c;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const communities = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        if (communities.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
+            return;
+        const query = createQuery(queryCommunities, Object.assign(Object.assign({}, queryParams), { page: (_c = collection === null || collection === void 0 ? void 0 : collection.params.page) !== null && _c !== void 0 ? _c : { limit } }));
+        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
+            const data = {
+                loading,
+                error,
+                params: { page },
+                data: communities,
+            };
+            if (result) {
+                data.data = [...new Set([...communities, ...result.map(getResolver('community'))])];
+            }
+            pushToCache(cacheKey, data);
+            responder(data);
+        }, queryOptions(policy));
+    };
+    disposers.push(onCommunityCreated(realtimeRouter()), onCommunityDeleted(realtimeRouter()), onCommunityUpdated(realtimeRouter()), onCommunityJoined(realtimeRouter()), onCommunityLeft(realtimeRouter()), onCommunityUserChanged(realtimeRouter()));
+    onFetch();
+    return () => {
+        log(`liveCommunities(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 /**
  * ```js
  * import { queryCategories } from '@amityco/ts-sdk'
@@ -27762,6 +27965,96 @@ getCategory.locally = (categoryId) => {
     };
 };
 
+/**
+ * ```js
+ * import { liveCategories } from '@amityco/ts-sdk'
+ *
+ * let categories = []
+ * const unsub = liveCategories({}, response => merge(categories, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Category}s
+ *
+ * @param params for querying categories
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the categories
+ *
+ * @category Category Live Collection
+ */
+const liveCategories = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveCategories(tmpid: ${timestamp}) > listen`);
+    const { limit: queryLimit } = params, queryParams = __rest(params, ["limit"]);
+    const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
+    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
+    const disposers = [];
+    const cacheKey = ['category', 'collection', {}];
+    const responder = (data) => {
+        var _a, _b;
+        let categories = (_a = data.data
+            .map(categoryId => pullFromCache(['category', 'get', categoryId]))
+            .filter(Boolean)
+            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+        categories = filterByPropEquality(categories, 'isDeleted', params.isDeleted);
+        switch (params.sortBy) {
+            case 'firstCreated':
+                categories = categories.sort(sortByFirstCreated);
+                break;
+            case 'lastCreated':
+                categories = categories.sort(sortByLastCreated);
+                break;
+            default:
+                categories = categories.sort(sortByName);
+        }
+        callback({
+            onNextPage: onFetch,
+            data: categories,
+            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    /*
+     * const realtimeRouter = () => {
+     * @TODO: At the time of creating this method category does not have any
+     * observers
+     *};
+     */
+    const onFetch = () => {
+        var _a, _b, _c;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const categories = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        if (categories.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
+            return;
+        const query = createQuery(queryCategories, Object.assign(Object.assign({}, queryParams), { page: (_c = collection === null || collection === void 0 ? void 0 : collection.params.page) !== null && _c !== void 0 ? _c : { limit } }));
+        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
+            const data = {
+                loading,
+                error,
+                params: { page },
+                data: categories,
+            };
+            if (result) {
+                data.data = [...new Set([...categories, ...result.map(getResolver('category'))])];
+            }
+            pushToCache(cacheKey, data);
+            responder(data);
+        }, queryOptions(policy));
+    };
+    disposers.push(() => {
+        // @TODO -> update once observers added
+    });
+    onFetch();
+    return () => {
+        log(`liveCategories(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 /**
  * ```js
  * import { queryGlobalFeed } from '@amityco/ts-sdk'
@@ -28686,6 +28979,38 @@ const observePost = (postId, callback, policy = 'cache_then_server') => {
     };
 };
 
+/**
+ * ```js
+ * import { livePost } from '@amityco/ts-sdk';
+ *
+ * let post;
+ *
+ * const unsubscribe = livePost(postId, response => {
+ *   post = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Post}
+ *
+ * @param postId the ID of the message to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the sub channel
+ *
+ * @category Post Live Object
+ */
+const livePost = (postId, callback) => {
+    return liveObject(postId, callback, 'postId', getPost, [
+        onPostApproved,
+        onPostDeclined,
+        onPostDeleted,
+        onPostFlagged,
+        onPostReactionAdded,
+        onPostReactionRemoved,
+        onPostUnflagged,
+        onPostUpdated,
+    ]);
+};
+
 /**
  * ```js
  * import { livePosts } from '@amityco/ts-sdk'
@@ -28699,8 +29024,8 @@ const observePost = (postId, callback, policy = 'cache_then_server') => {
  *
  * Observe all mutations on a list of {@link Amity.Post} for a given target object
  *
- * @param targetType the type of the target
- * @param targetId the ID of the target
+ * @param param.targetType the type of the target
+ * @param param.targetId the ID of the target
  * @param callback the function to call when new data are available
  * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
  *
@@ -28734,6 +29059,9 @@ const livePosts = (params, callback, config) => {
         if (params.tags) {
             posts = posts.filter(p => { var _a; return (_a = p.tags) === null || _a === void 0 ? void 0 : _a.some(t => { var _a; return (_a = params.tags) === null || _a === void 0 ? void 0 : _a.includes(t); }); });
         }
+        if (params.targetType === 'community' && params.feedType) {
+            posts = filterByFeedType(posts, params.feedType);
+        }
         callback({
             onNextPage: onFetch,
             data: posts,
@@ -28747,27 +29075,16 @@ const livePosts = (params, callback, config) => {
         const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
         if (params.targetId !== post.targetId || params.targetType !== post.targetType || !collection)
             return;
-        if (['onCreate', 'onApproved'].includes(action)) {
-            collection.data = [...new Set([post.postId, ...collection.data])];
-        }
-        else if (['onDelete', 'onDeclined'].includes(action)) {
-            collection.data = collection.data.filter(p => p !== post.postId);
-            /*
-             * if isDeleted is true, collection should add deleted items to the
-             * begining of the collection
-             */
-            if (params.isDeleted)
-                collection.data.unshift(post.postId);
-        }
         /*
-         * FIX-ME
-         * This is a shortcoming as the feed object is not saved to the cache.
-         * The responder should pull the feed from cache once available and should
-         * match the collection to feedType param
-         * https://ekoapp.atlassian.net/browse/ASC-9382
+         * This is not ideal, but currently this is the only way to update the
+         * collection on post declined
          */
-        if (params.feedType === 'reviewing' && action === 'onApproved')
-            collection.data = collection.data.filter(p => p !== post.postId);
+        if (action === 'onDeclined') {
+            collection.data = collection.data.filter(postId => postId !== post.postId);
+        }
+        else {
+            collection.data = [...new Set([post.postId, ...collection.data])];
+        }
         pushToCache(cacheKey, collection);
         responder(collection);
     };
@@ -28881,6 +29198,36 @@ const observeComment = (commentId, callback, policy = 'cache_then_server') => {
     };
 };
 
+/**
+ * ```js
+ * import { liveComment } from '@amityco/ts-sdk';
+ *
+ * let comment;
+ *
+ * const unsubscribe = liveComment(commentId, response => {
+ *   comment = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Comment}
+ *
+ * @param commentId the ID of the comment to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
+ *
+ * @category Comment Live Object
+ */
+const liveComment = (commentId, callback) => {
+    return liveObject(commentId, callback, 'commentId', getComment, [
+        onCommentDeleted,
+        onCommentFlagged,
+        onCommentReactionAdded,
+        onCommentReactionRemoved,
+        onCommentUnflagged,
+        onCommentUpdated,
+    ]);
+};
+
 /**
  * ```js
  * import { liveComments } from '@amityco/ts-sdk'
@@ -29622,6 +29969,7 @@ exports.dropFromCache = dropFromCache;
 exports.enableCache = enableCache;
 exports.fileUrlWithSize = fileUrlWithSize;
 exports.filterByChannelMembership = filterByChannelMembership;
+exports.filterByFeedType = filterByFeedType;
 exports.filterByPropEquality = filterByPropEquality;
 exports.filterByPropInclusion = filterByPropInclusion;
 exports.follow = follow;
@@ -29673,24 +30021,29 @@ exports.isMutator = isMutator;
 exports.isOffline = isOffline;
 exports.isPaged = isPaged;
 exports.isReportedByMe = isReportedByMe;
-exports.isSkipLimit = isSkipLimit;
+exports.isSkip = isSkip;
 exports.joinChannel = joinChannel;
 exports.joinCommunity = joinCommunity;
 exports.leaveChannel = leaveChannel;
 exports.leaveCommunity = leaveCommunity;
+exports.liveCategories = liveCategories;
 exports.liveChannel = liveChannel;
 exports.liveChannelMembers = liveChannelMembers;
 exports.liveChannels = liveChannels;
+exports.liveComment = liveComment;
 exports.liveComments = liveComments;
+exports.liveCommunities = liveCommunities;
 exports.liveFollowers = liveFollowers;
 exports.liveFollowings = liveFollowings;
 exports.liveMessage = liveMessage;
 exports.liveMessages = liveMessages;
+exports.livePost = livePost;
 exports.livePosts = livePosts;
 exports.liveReactions = liveReactions;
 exports.liveSubChannel = liveSubChannel;
 exports.liveSubChannels = liveSubChannels;
 exports.liveUser = liveUser;
+exports.liveUsers = liveUsers;
 exports.mergeInCache = mergeInCache;
 exports.observeChannel = observeChannel;
 exports.observeChannels = observeChannels;
@@ -29733,6 +30086,7 @@ exports.onCommunityLeft = onCommunityLeft;
 exports.onCommunityUpdated = onCommunityUpdated;
 exports.onCommunityUserAdded = onCommunityUserAdded;
 exports.onCommunityUserBanned = onCommunityUserBanned;
+exports.onCommunityUserChanged = onCommunityUserChanged;
 exports.onCommunityUserRemoved = onCommunityUserRemoved;
 exports.onCommunityUserUnbanned = onCommunityUserUnbanned;
 exports.onConnectionError = onConnectionError;
@@ -29812,6 +30166,7 @@ exports.sortByDisplayName = sortByDisplayName;
 exports.sortByFirstCreated = sortByFirstCreated;
 exports.sortByLastActivity = sortByLastActivity;
 exports.sortByLastCreated = sortByLastCreated;
+exports.sortByName = sortByName;
 exports.sortBySegmentNumber = sortBySegmentNumber;
 exports.startReading = startReading;
 exports.stopReading = stopReading;