@amityco/ts-sdk 0.0.1-beta.33 → 0.0.1-beta.36

package/dist/index.cjs.js

@@ -106,6 +106,78 @@ const isProduction = ((_a$1 = safeProcess.env) === null || _a$1 === void 0 ? voi
 var _a, _b;
 const VERSION$1 = (_b = (_a = safeProcess.env) === null || _a === void 0 ? void 0 : _a.VERSION) !== null && _b !== void 0 ? _b : '__dev__';
 
+// cache constants
+const CACHE_KEY_GET = 'get';
+const CACHE_KEY_TOMBSTONE = 'dead';
+const CACHE_LIFESPAN = 1 * 60 * 1000; // 1 minute
+const CACHE_LIFESPAN_TOMBSTONE = 3 * 60 * 1000; // 3 minutes
+/**
+ * Shallow-clones an object and sort its keys
+ *
+ * @param source a plain object to clone
+ * @returns a clone of source, with keys sorted with default javascript sorting
+ *
+ * @category Cache
+ * @hidden
+ */
+const normalize = (source) => Object.keys(source)
+    .sort()
+    .reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: source[key] })), {});
+/**
+ * Encodes a given {@link Amity.CacheKey} to a plain string
+ *
+ * @param key the key to encode
+ * @returns an encoded string
+ *
+ * @category Cache
+ * @hidden
+ */
+const encodeKey = (key) => JSON.stringify(key, (_, val) => (typeof val === 'object' ? normalize(val) : val));
+/**
+ * Decodes a string back into a {@link Amity.CacheKey}
+
+ *
+ * @param key the string key to decode
+ * @returns a plain Amity.CacheKey object.
+ *
+ * @category Cache
+ * @hidden
+ */
+const decodeKey = (key) => JSON.parse(key);
+/**
+ * Performs a recursive partial deep equal check on two objects.
+ *
+ * @param predicate the reference object containing the partial information
+ * @param candidate the object to check against
+ * @returns true if the candidate contains all the values of the predicate
+ *
+ * @category Cache
+ */
+const partialMatch = (predicate, candidate) => {
+    if (predicate === candidate)
+        return true;
+    // if one or the other is nullish, there can't be equality
+    if (!predicate || !candidate)
+        return false;
+    // we only perform recursive check on objects
+    if (typeof predicate !== 'object') {
+        return false;
+    }
+    // recursively call for partial match based on the predicate
+    return Object.keys(predicate).every(key => partialMatch(predicate[key], candidate[key]));
+};
+/**
+ * checks if passed error code is included in
+ * Tombstone errors list
+ *
+ * @param errorCode as {@link Amity.ServerError}
+ * @returns success boolean if the given errorCode
+ * is included in Tombstone errors list
+ *
+ * @category Cache
+ */
+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
  *
@@ -255,12 +327,180 @@ const toPageRaw = (token) => {
     return undefined;
 };
 
+/* eslint-disable no-use-before-define */
+/**
+ * Type guard to check and cast that a given async function is has the ".locally" property
+ *
+ * @param func any SDK APi function
+ * @returns success boolean if the function has a 'locally' twin
+ *
+ * @hidden
+ */
+const isFetcher = (func) => 'locally' in func;
+/**
+ * Type guard to check and cast that a given async function is has the ".optimistically" property
+ *
+ * @param func any SDK APi function
+ * @returns success boolean if the function has an 'optimistically' twin
+ *
+ * @hidden
+ */
+const isMutator = (func) => 'optimistically' in func;
+/**
+ * Type guard to check and cast that a given async function is has
+ * the ".locally" or ".optimistically" property
+ *
+ * @param func any SDK APi function
+ * @returns success boolean if the function has an offline twin
+ *
+ * @hidden
+ */
+const isOffline = (func) => isFetcher(func) || isMutator(func);
+/**
+ * Type guard to check and cast that a given object has the "cachedAt" property
+ *
+ * @param model any object to check on
+ * @returns success boolean if the object has property "cachedAt"
+ *
+ * @hidden
+ */
+const isCachable = (model) => model === null || model === void 0 ? void 0 : model.hasOwnProperty('cachedAt');
+/**
+ * Checks if a model is considered local (cachedAt === -1)
+ *
+ * @param model any cachable object to check
+ * @returns success boolean if the object is marked as local
+ *
+ * @hidden
+ */
+const isLocal = (model) => {
+    return isCachable(model) && (model === null || model === void 0 ? void 0 : model.cachedAt) === -1;
+};
+/**
+ * Checks if a model is considered fresh
+ *
+ * @param model any cachable object to check
+ * @param lifeSpan the supposedly duration for which the object is considered synced
+ * @returns success boolean if the object is below the given lifespan
+ *
+ * @hidden
+ */
+const isFresh = (model, lifeSpan = CACHE_LIFESPAN) => {
+    var _a;
+    return Date.now() - ((_a = model === null || model === void 0 ? void 0 : model.cachedAt) !== null && _a !== void 0 ? _a : 0) <= lifeSpan;
+};
+/**
+ * ```js
+ * import { createQuery, getUser } from '@amityco/ts-sdk'
+ * const query = createQuery(getUser, 'foobar')
+ * ```
+ *
+ * Creates a wrapper for the API call you wish to call.
+ * This wrapper is necessary to create for optimistically calls
+ *
+ *
+ * @param func A compatible API function from the ts sdk
+ * @param args The arguments to pass to the function passed as `fn`
+ * @returns A wrapper containing both the function and its future arguments
+ *
+ * @category Query
+ */
+const createQuery = (func, ...args) => ({ func, args });
+/**
+ * ```js
+ * import { queryOptions } from '@amityco/ts-sdk'
+ * const options = queryOptions('no_fetch', lifeSpan)
+ * ```
+ *
+ * Creates a query options object based on the query policy passed
+ *
+ * @param policy The policy to apply to a query
+ * @returns A properly set query options object
+ *
+ * @category Query
+ */
+const queryOptions = (policy, lifeSpan = CACHE_LIFESPAN) => {
+    if (policy === 'cache_only')
+        return { lifeSpan: Infinity };
+    return { lifeSpan: lifeSpan < CACHE_LIFESPAN ? CACHE_LIFESPAN : lifeSpan };
+};
+/**
+ * ```js
+ * import { createQuery, getUser, runQuery } from '@amityco/ts-sdk'
+ * const query = createQuery(getUser, client, 'foobar')
+ * runQuery(query,  user => console.log(user))
+ * ```
+ *
+ * Calls an API function wrapped around a Amity.Query, and executes the callback whenever
+ * a value is available. The value can be picked either from the local cache and/or
+ * from the server afterwards depending on the query options passed
+ *
+ * @param query A query object wrapping the call to be made
+ * @param callback A function to execute when a value is available
+ * @param options the query options
+ *
+ * @category Query
+ */
+const runQuery = ({ func, args }, callback, options = queryOptions('cache_then_server')) => {
+    let local;
+    const { lifeSpan } = queryOptions('cache_then_server', options.lifeSpan);
+    // offline first
+    if (isOffline(func)) {
+        try {
+            local = isMutator(func) ? func.optimistically(...args) : func.locally(...args);
+        }
+        catch (error) {
+            callback === null || callback === void 0 ? void 0 : callback(createSnapshot(undefined, {
+                origin: 'local',
+                loading: false,
+                error,
+            }));
+        }
+        const shouldAbort = isCachable(local) && isFresh(local, lifeSpan);
+        callback === null || callback === void 0 ? void 0 : callback(createSnapshot(local, {
+            origin: 'local',
+            loading: !(isFetcher(func) && shouldAbort),
+        }));
+        if (shouldAbort)
+            return;
+    }
+    else {
+        callback === null || callback === void 0 ? void 0 : callback(createSnapshot(undefined, {
+            origin: 'local',
+            loading: true,
+        }));
+    }
+    func(...args)
+        .then(fresh => {
+        // @ts-ignore i know.
+        // isLocal(local) && syncInCache(local, fresh)
+        callback === null || callback === void 0 ? void 0 : callback(createSnapshot(fresh, {
+            origin: 'server',
+            loading: false,
+        }));
+    })
+        .catch(error => {
+        callback === null || callback === void 0 ? void 0 : callback(createSnapshot(undefined, {
+            origin: 'server',
+            loading: false,
+            error,
+        }));
+    });
+};
+// eslint-disable-next-line no-redeclare
+function createSnapshot(data, options) {
+    if (isPaged(data) || isCachable(data))
+        return Object.assign(Object.assign({}, options), data);
+    return Object.assign(Object.assign({}, options), { data });
+}
+
 /** @hidden */
 const idResolvers = {
     user: ({ userId }) => userId,
     file: ({ fileId }) => fileId,
     role: ({ roleId }) => roleId,
     channel: ({ channelId }) => channelId,
+    subChannel: ({ subChannelId }) => subChannelId,
     channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
     message: ({ messageId }) => messageId,
     community: ({ communityId }) => communityId,
@@ -297,6 +537,7 @@ const CRITERIAS = {
     user: ['userId', 'avatarFileId'],
     role: ['roleId'],
     channel: ['channelId', 'rateLimit'],
+    subChannel: ['subChannelId'],
     channelUsers: ['channelId', 'userId', 'membership'],
     message: ['messageId'],
     community: ['communityId', 'postSetting'],
@@ -355,6 +596,7 @@ const PAYLOAD2MODEL = {
     files: 'file',
     roles: 'role',
     channels: 'channel',
+    messageFeeds: 'subChannel',
     channelUsers: 'channelUsers',
     messages: 'message',
     communities: 'community',
@@ -368,277 +610,17 @@ const PAYLOAD2MODEL = {
     videoStreamings: 'stream',
     follows: 'follow',
     followCounts: 'followCount',
-};
+};
+/** hidden */
+const hasUpdates = (prevData, nextData) => {
+    return new Date(prevData.updatedAt) < new Date(nextData.updatedAt);
+};
+/** hidden */
+function getFutureDate(date = new Date().toISOString()) {
+    return new Date(new Date(date).getTime() + 1).toISOString();
+}
 
-// cache constants
-const CACHE_KEY_GET = 'get';
-const CACHE_KEY_TOMBSTONE = 'dead';
-const CACHE_LIFESPAN = 1 * 60 * 1000; // 1 minute
-const CACHE_LIFESPAN_TOMBSTONE = 3 * 60 * 1000; // 3 minutes
-/**
- * Shallow-clones an object and sort its keys
- *
- * @param source a plain object to clone
- * @returns a clone of source, with keys sorted with default javascript sorting
- *
- * @category Cache
- * @hidden
- */
-const normalize = (source) => Object.keys(source)
-    .sort()
-    .reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: source[key] })), {});
-/**
- * Encodes a given {@link Amity.CacheKey} to a plain string
- *
- * @param key the key to encode
- * @returns an encoded string
- *
- * @category Cache
- * @hidden
- */
-const encodeKey = (key) => JSON.stringify(key, (_, val) => (typeof val === 'object' ? normalize(val) : val));
-/**
- * Decodes a string back into a {@link Amity.CacheKey}
-
- *
- * @param key the string key to decode
- * @returns a plain Amity.CacheKey object.
- *
- * @category Cache
- * @hidden
- */
-const decodeKey = (key) => JSON.parse(key);
-/**
- * Performs a recursive partial deep equal check on two objects.
- *
- * @param predicate the reference object containing the partial information
- * @param candidate the object to check against
- * @returns true if the candidate contains all the values of the predicate
- *
- * @category Cache
- */
-const partialMatch = (predicate, candidate) => {
-    if (predicate === candidate)
-        return true;
-    // if one or the other is nullish, there can't be equality
-    if (!predicate || !candidate)
-        return false;
-    // we only perform recursive check on objects
-    if (typeof predicate !== 'object') {
-        return false;
-    }
-    // recursively call for partial match based on the predicate
-    return Object.keys(predicate).every(key => partialMatch(predicate[key], candidate[key]));
-};
-/**
- * checks if passed error code is included in
- * Tombstone errors list
- *
- * @param errorCode as {@link Amity.ServerError}
- * @returns success boolean if the given errorCode
- * is included in Tombstone errors list
- *
- * @category Cache
- */
-const checkIfShouldGoesToTombstone = (errorCode) => [400400 /* Amity.ServerError.ITEM_NOT_FOUND */, 400300 /* Amity.ServerError.FORBIDDEN */].includes(errorCode);
-
-/* eslint-disable no-use-before-define */
-/**
- * Type guard to check and cast that a given async function is has the ".locally" property
- *
- * @param func any SDK APi function
- * @returns success boolean if the function has a 'locally' twin
- *
- * @hidden
- */
-const isFetcher = (func) => 'locally' in func;
-/**
- * Type guard to check and cast that a given async function is has the ".optimistically" property
- *
- * @param func any SDK APi function
- * @returns success boolean if the function has an 'optimistically' twin
- *
- * @hidden
- */
-const isMutator = (func) => 'optimistically' in func;
-/**
- * Type guard to check and cast that a given async function is has
- * the ".locally" or ".optimistically" property
- *
- * @param func any SDK APi function
- * @returns success boolean if the function has an offline twin
- *
- * @hidden
- */
-const isOffline = (func) => isFetcher(func) || isMutator(func);
-/**
- * Type guard to check and cast that a given object has the "cachedAt" property
- *
- * @param model any object to check on
- * @returns success boolean if the object has property "cachedAt"
- *
- * @hidden
- */
-const isCachable = (model) => model === null || model === void 0 ? void 0 : model.hasOwnProperty('cachedAt');
-/**
- * Checks if a model is considered local (cachedAt === -1)
- *
- * @param model any cachable object to check
- * @returns success boolean if the object is marked as local
- *
- * @hidden
- */
-const isLocal = (model) => {
-    return isCachable(model) && (model === null || model === void 0 ? void 0 : model.cachedAt) === -1;
-};
-/**
- * Checks if a model is considered fresh
- *
- * @param model any cachable object to check
- * @param lifeSpan the supposedly duration for which the object is considered synced
- * @returns success boolean if the object is below the given lifespan
- *
- * @hidden
- */
-const isFresh = (model, lifeSpan = CACHE_LIFESPAN) => {
-    var _a;
-    return Date.now() - ((_a = model === null || model === void 0 ? void 0 : model.cachedAt) !== null && _a !== void 0 ? _a : 0) <= lifeSpan;
-};
-/**
- * ```js
- * import { createQuery, getUser } from '@amityco/ts-sdk'
- * const query = createQuery(getUser, 'foobar')
- * ```
- *
- * Creates a wrapper for the API call you wish to call.
- * This wrapper is necessary to create for optimistically calls
- *
- *
- * @param func A compatible API function from the ts sdk
- * @param args The arguments to pass to the function passed as `fn`
- * @returns A wrapper containing both the function and its future arguments
- *
- * @category Query
- */
-const createQuery = (func, ...args) => ({ func, args });
-/**
- * ```js
- * import { queryOptions } from '@amityco/ts-sdk'
- * const options = queryOptions('no_fetch', lifeSpan)
- * ```
- *
- * Creates a query options object based on the query policy passed
- *
- * @param policy The policy to apply to a query
- * @returns A properly set query options object
- *
- * @category Query
- */
-const queryOptions = (policy, lifeSpan = CACHE_LIFESPAN) => {
-    if (policy === 'cache_only')
-        return { lifeSpan: Infinity };
-    return { lifeSpan: lifeSpan < CACHE_LIFESPAN ? CACHE_LIFESPAN : lifeSpan };
-};
-/**
- * ```js
- * import { createQuery, getUser, runQuery } from '@amityco/ts-sdk'
- * const query = createQuery(getUser, client, 'foobar')
- * runQuery(query,  user => console.log(user))
- * ```
- *
- * Calls an API function wrapped around a Amity.Query, and executes the callback whenever
- * a value is available. The value can be picked either from the local cache and/or
- * from the server afterwards depending on the query options passed
- *
- * @param query A query object wrapping the call to be made
- * @param callback A function to execute when a value is available
- * @param options the query options
- *
- * @category Query
- */
-const runQuery = ({ func, args }, callback, options = queryOptions('cache_then_server')) => {
-    let local;
-    const { lifeSpan } = queryOptions('cache_then_server', options.lifeSpan);
-    // offline first
-    if (isOffline(func)) {
-        try {
-            local = isMutator(func) ? func.optimistically(...args) : func.locally(...args);
-        }
-        catch (error) {
-            callback === null || callback === void 0 ? void 0 : callback(createSnapshot(undefined, {
-                origin: 'local',
-                loading: false,
-                error,
-            }));
-        }
-        const shouldAbort = isCachable(local) && isFresh(local, lifeSpan);
-        callback === null || callback === void 0 ? void 0 : callback(createSnapshot(local, {
-            origin: 'local',
-            loading: !(isFetcher(func) && shouldAbort),
-        }));
-        if (shouldAbort)
-            return;
-    }
-    else {
-        callback === null || callback === void 0 ? void 0 : callback(createSnapshot(undefined, {
-            origin: 'local',
-            loading: true,
-        }));
-    }
-    let optimisticArgs = args;
-    /* get args for optimistic method calls
-     *
-     * On optimistic updates, the modal key for the update needs to be passed to
-     * the server so as to avoid duplicate modal creation
-     *
-     * ex: on creating a new message pass the modalKey is messageId, pass this
-     * id onto the server so that a duplicate with seperate messageId is not
-     * created.
-     */
-    if (isMutator(func)) {
-        // @ts-ignore
-        const modelKey = local && local.data && identifyModelKey(local.data);
-        if (modelKey) {
-            /*
-             * modal key is only required for create as update and delete queries pass
-             * the modal key in the param itself
-             * For update & delete the first argument is always an id which is of type
-             * string, whereas for create the first and only argument is the param object
-             *
-             * When creating an AmityObject optimistically we need to pass the modal key
-             * on to the server. ex: for create message modal key will be 'messageId`
-             */
-            if (typeof args[0] !== 'string') {
-                // @ts-ignore
-                optimisticArgs = [Object.assign(Object.assign({}, args[0]), { [modelKey]: local.data[modelKey] })];
-            }
-        }
-    }
-    func(...optimisticArgs)
-        .then(fresh => {
-        // @ts-ignore i know.
-        // isLocal(local) && syncInCache(local, fresh)
-        callback === null || callback === void 0 ? void 0 : callback(createSnapshot(fresh, {
-            origin: 'server',
-            loading: false,
-        }));
-    })
-        .catch(error => {
-        callback === null || callback === void 0 ? void 0 : callback(createSnapshot(undefined, {
-            origin: 'server',
-            loading: false,
-            error,
-        }));
-    });
-};
-// eslint-disable-next-line no-redeclare
-function createSnapshot(data, options) {
-    if (isPaged(data) || isCachable(data))
-        return Object.assign(Object.assign({}, options), data);
-    return Object.assign(Object.assign({}, options), { data });
-}
-
-/* eslint-disable max-classes-per-file */
+/* eslint-disable max-classes-per-file */
 /**
  * Generic ASC error
  * @category Errors
@@ -1094,16 +1076,10 @@ const filterByChannelMembership = (collection, membership, userId) => {
             'get',
             channelUserCacheKey,
         ])) === null || _a === void 0 ? void 0 : _a.data;
-        // if channel user is defined for user, user is a member
-        if (membership === 'member' && channelUser) {
-            return true;
-        }
-        // if channel user by user id not found, user is not a member of that
-        // channel
-        if (membership === 'notMember' && !channelUser) {
+        if (membership === 'member' && channelUser && channelUser.membership !== 'none') {
             return true;
         }
-        return false;
+        return membership === 'notMember' && (!channelUser || channelUser.membership === 'none');
     });
 };
 
@@ -1164,19 +1140,6 @@ const WS_EVENTS = [
     'connect_error',
     'reconnect_error',
     'reconnect_failed',
-    'v3.channel.didCreate',
-    'v3.channel.didUpdate',
-    'v3.channel.didDelete',
-    'v3.channel.didJoin',
-    'v3.channel.didLeave',
-    'v3.channel.didAddUsers',
-    'v3.channel.didRemoveUsers',
-    'v3.channel.didBan',
-    'v3.channel.didUnban',
-    'v3.message.didFetch',
-    'v3.message.didCreate',
-    'v3.message.didUpdate',
-    'v3.message.didDelete',
 ];
 const MQTT_EVENTS = [
     'connect',
@@ -1203,16 +1166,23 @@ const createEventEmitter = () => {
  */
 const proxyWebsocketEvents = (ws, emitter) => {
     WS_EVENTS.forEach(event => {
-        ws.on(event, (param) => emitter.emit(event, param));
+        ws.on(event, (param) => {
+            console.log('ws', event, param);
+            emitter.emit(event, param);
+        });
     });
 };
 const proxyMqttEvents = (mqttClient, emitter) => {
     MQTT_EVENTS.forEach(event => {
-        mqttClient.on(event, (...params) => emitter.emit(event, params.length === 1 ? params[0] : params));
+        mqttClient.on(event, (...params) => {
+            console.log('mqtt', event, params);
+            emitter.emit(event, params.length === 1 ? params[0] : params);
+        });
     });
     // @ts-ignore
     mqttClient.on('message', (topic, payload) => {
         const message = JSON.parse(payload.toString());
+        console.log('mqtt message', message);
         emitter.emit(message.eventType, message.data);
     });
 };
@@ -1292,6 +1262,7 @@ const getCommunityUserTopic = (path, level) => {
             return path;
     }
 };
+const getNetworkId = (user) => user.path.split('/user/')[0];
 const getCommunityTopic = ({ path }, level = exports.SubscriptionLevels.COMMUNITY) => getCommunityUserTopic(path, level);
 const getUserTopic = ({ path }, level = exports.SubscriptionLevels.USER) => getCommunityUserTopic(level === exports.SubscriptionLevels.USER ? path : path.replace(/^(\w*)/, '$1/social'), level);
 const getPostTopic = ({ path }, level = exports.SubscriptionLevels.POST) => {
@@ -1307,24 +1278,54 @@ const getCommentTopic = ({ path }) => {
 };
 const getMyFollowersTopic = () => {
     const user = getActiveUser();
-    const [networkId] = user.path.split('/user/');
-    return `${networkId}/membership/${user._id}/+/+`;
+    return `${getNetworkId(user)}/membership/${user._id}/+/+`;
 };
 const getMyFollowingsTopic = () => {
     const user = getActiveUser();
-    const [networkId] = user.path.split('/user/');
-    return `${networkId}/membership/+/${user._id}/+`;
+    return `${getNetworkId(user)}/membership/+/${user._id}/+`;
 };
-/** @hidden */
+const getChannelTopic = (channel) => `${channel.path}/#`;
+const getSubChannelTopic = (subChannel) => `${subChannel.path}/#`;
+const getMessageTopic = (message) => message.path;
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to network level events like 'user is deleted from the network'
+ */
 const getNetworkTopic = () => {
-    const user = getActiveUser();
-    const [networkId] = user.path.split('/user/');
-    return networkId;
+    return getNetworkId(getActiveUser());
 };
-let mqttAccessToken;
-let mqttUserId;
-function subscribeTopic(topic, callback) {
-    const { mqtt, emitter, accessToken } = getActiveClient();
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to channel events for 'conversation', 'community' channel
+ */
+const getSmartFeedChannelTopic = () => {
+    const user = getActiveUser();
+    return `${getNetworkId(user)}/smartfeed/${user._id}/channels`;
+};
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to sub channel events for 'conversation', 'community' channel
+ */
+const getSmartFeedSubChannelTopic = () => {
+    const user = getActiveUser();
+    return `${getNetworkId(user)}/smartfeed/${user._id}/messagefeeds`;
+};
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to message events for 'conversation', 'community' channel
+ */
+const getSmartFeedMessageTopic = () => {
+    const user = getActiveUser();
+    return `${getNetworkId(user)}/smartfeed/${user._id}/messages`;
+};
+let mqttAccessToken;
+let mqttUserId;
+function subscribeTopic(topic, callback) {
+    const { mqtt, emitter, accessToken } = getActiveClient();
     const user = getActiveUser();
     if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
         mqttAccessToken = accessToken;
@@ -20335,7 +20336,7 @@ const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAU
         getFeedSettings,
     };
     try {
-        getActiveClient();
+        return getActiveClient();
     }
     catch (_c) {
         setActiveClient(client);
@@ -20586,9 +20587,8 @@ const connectClient = async (params, config) => {
     // @ts-ignore: in that particular case, typing can be
     // ignored since we enforce default values just before.
     const { accessToken, users } = await getToken(params);
-    // manually setup the token for http transport
+    // manually setup the token for http, ws transport
     client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
-    // manually setup the token for ws transport
     client.ws.io.opts.query = { token: accessToken };
     // FIXME: events are duplicated if connectClient is called few times without disconnectClient
     // wire websocket events to our event emitter
@@ -20604,6 +20604,9 @@ const connectClient = async (params, config) => {
     setActiveUser(users[0]);
     if ((config === null || config === void 0 ? void 0 : config.disableRTE) !== true) {
         subscribeTopic(getNetworkTopic());
+        subscribeTopic(getSmartFeedChannelTopic());
+        subscribeTopic(getSmartFeedSubChannelTopic());
+        subscribeTopic(getSmartFeedMessageTopic());
     }
     const subscriptions = [
         onClientBanned(() => {
@@ -20956,23 +20959,6 @@ const updateUser = async (userId, patch) => {
     };
 };
 
-/**
- * ```js
- * import { onUserFetched } from '@amityco/ts-sdk'
- * const dispose = onUserFetched(user => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.User} has been fetched
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category User Events
- */
-const onUserFetched = (callback) => createUserEventSubscriber('user.fetched', callback);
-
 /**
  * ```js
  * import { onUserUpdated } from '@amityco/ts-sdk'
@@ -21050,52 +21036,72 @@ const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;
 
 /**
  * ```js
- * import { liveUser } from '@amityco/ts-sdk'
+ * import { onUserFetched } from '@amityco/ts-sdk'
+ * const dispose = onUserFetched(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+const onUserFetched = (callback) => createUserEventSubscriber('user.fetched', callback);
+
+/**
+ * ```js
+ * import { liveUser } from '@amityco/ts-sdk';
  *
- * let users = []
- * const unsub = liveUser(userId, response => merge(users, response.data))
+ * let user;
+ *
+ * const unsubscribe = liveUser(userId, response => {
+ *   user = response.data;
+ * });
  * ```
  *
  * Observe all mutation on a given {@link Amity.User}
  *
  * @param userId the ID of the user 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 users
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the user
  *
  * @category Message Live Object
  */
 const liveUser = (userId, callback) => {
     const { log, cache } = getActiveClient();
-    let user;
+    const timestamp = Date.now();
+    log(`liveUser(tmpid: ${timestamp}) > listen`);
     if (!cache) {
         console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
     }
-    const timestamp = Date.now();
-    log(`liveUser(tmpid: ${timestamp}) > listen`);
+    let user;
     const disposers = [];
     const dispatcher = (data) => {
-        var _a;
-        // we check updatedAt to see if the current snapshot is new so
-        // we won't send old data back, only fresh new data
-        if (user && ((_a = data.data) === null || _a === void 0 ? void 0 : _a.updatedAt) === (user === null || user === void 0 ? void 0 : user.updatedAt) && data.origin !== 'server')
-            return;
-        callback(data);
         user = data.data;
+        callback(data);
     };
-    const realtimeRouter = (user, action) => {
-        dispatcher({ loading: false, data: user, origin: 'event' });
+    const realtimeRouter = (eventUser) => {
+        if (userId !== eventUser.userId) {
+            return;
+        }
+        if (user && !hasUpdates(user, eventUser)) {
+            return;
+        }
+        dispatcher({ loading: false, data: eventUser, origin: 'event' });
     };
     const onFetch = () => {
         const query = createQuery(getUser, userId, true);
         runQuery(query, ({ loading, data, error, origin }) => {
             dispatcher({ loading, data, origin, error });
             if (error) {
-                // Terminate observe functionality on error
                 disposers.forEach(fn => fn());
             }
         });
     };
-    disposers.push(onUserFetched(user => realtimeRouter(user)), onUserUpdated(user => realtimeRouter(user)), onUserDeleted(user => realtimeRouter(user)), onUserFlagged(user => realtimeRouter(user)), onUserUnflagged(user => realtimeRouter(user)), onUserFlagCleared(user => realtimeRouter(user)));
+    disposers.push(onUserFetched(realtimeRouter), onUserUpdated(realtimeRouter), onUserDeleted(realtimeRouter), onUserFlagged(realtimeRouter), onUserUnflagged(realtimeRouter), onUserFlagCleared(realtimeRouter));
     onFetch();
     return () => {
         log(`liveUser(tmpid: ${timestamp}) > dispose`);
@@ -21509,7 +21515,7 @@ getRole.locally = (roleId) => {
 const dispatchReactable = (referenceType, model) => {
     if (referenceType === 'message')
         // @ts-ignore: refactor later
-        fireEvent('v3.message.didUpdate', { messages: [model] });
+        fireEvent('local.message.updated', { messages: [model] });
     else if (referenceType === 'post')
         // @ts-ignore: refactor later
         fireEvent('post.updated', { posts: [model] });
@@ -21518,6 +21524,100 @@ const dispatchReactable = (referenceType, model) => {
         fireEvent('comment.updated', { comments: [model] });
 };
 
+/** @hidden */
+/*
+ * @param message payload from http request without myReactions
+ * add myReactions to http response if the event was a reaction event
+ */
+const prepareMessagePayloadForCache = (payload) => {
+    const client = getActiveClient();
+    const cached = pullFromCache(['message', 'get', payload.messageId]);
+    // '[]' in cases where the new reaction is the first one
+    const myReactions = (cached === null || cached === void 0 ? void 0 : cached.data.myReactions) || [];
+    // add myReactions to the payload
+    Object.assign(payload, { myReactions });
+    // check if there are any updates to the reactions
+    const latestReaction = payload === null || payload === void 0 ? void 0 : payload.latestReaction;
+    const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
+    if (!isLatestReactionMine) {
+        return;
+    }
+    // new reaction added
+    if (latestReaction.eventName === 'add' && !myReactions.includes(latestReaction.reactionName)) {
+        Object.assign(payload, {
+            myReactions: [...myReactions, latestReaction.reactionName],
+        });
+    }
+    // existing reaction removed
+    if (latestReaction.eventName === 'remove' && myReactions.includes(latestReaction.reactionName)) {
+        Object.assign(payload, {
+            myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
+        });
+    }
+};
+
+function convertFromRaw$2(_a) {
+    var { channelPublicId, childCount, creatorPublicId, mentionedUsers, messageFeedId, myReactions, reactionCount, reactions, referenceId, segment } = _a, rest = __rest(_a, ["channelPublicId", "childCount", "creatorPublicId", "mentionedUsers", "messageFeedId", "myReactions", "reactionCount", "reactions", "referenceId", "segment"]);
+    let cache;
+    if (referenceId) {
+        try {
+            cache = pullFromCache(['message', 'get', referenceId]);
+            // eslint-disable-next-line no-empty
+        }
+        catch (_b) { }
+    }
+    if (!cache) {
+        try {
+            cache = pullFromCache(['message', 'get', rest.messageId]);
+            // eslint-disable-next-line no-empty
+        }
+        catch (_c) { }
+    }
+    const out = Object.assign(Object.assign({}, rest), { channelId: channelPublicId, channelSegment: segment, childrenNumber: childCount, creatorId: creatorPublicId, reactions: reactions !== null && reactions !== void 0 ? reactions : {}, reactionsCount: reactionCount, subChannelId: messageFeedId, uniqueId: cache ? cache.data.uniqueId : rest.messageId });
+    if (mentionedUsers) {
+        out.mentionees = mentionedUsers.map(mention => {
+            if (mention.type === 'channel') {
+                return mention;
+            }
+            return { type: 'user', userIds: mention.userPublicIds };
+        });
+    }
+    if (myReactions) {
+        // http response
+        out.myReactions = myReactions;
+    }
+    else {
+        // mqtt event
+        try {
+            prepareMessagePayloadForCache(out);
+            // eslint-disable-next-line no-empty
+        }
+        catch (_d) { }
+    }
+    return out;
+}
+const prepareMessagePayload = (payload) => {
+    return Object.assign(Object.assign({}, payload), { messages: payload.messages.map(convertFromRaw$2) });
+};
+const convertResponseFromRaw = (response) => {
+    return Object.assign(Object.assign({}, response), { data: Object.assign(Object.assign({}, response.data), { messages: response.data.messages.map(convertFromRaw$2) }) });
+};
+function convertParams(_a) {
+    var { subChannelId, mentionees } = _a, rest = __rest(_a, ["subChannelId", "mentionees"]);
+    return Object.assign({ messageFeedId: subChannelId, mentionedUsers: mentionees }, rest);
+}
+function convertQueryParams$1(_a) {
+    var { page, sortBy, subChannelId, tags } = _a, rest = __rest(_a, ["page", "sortBy", "subChannelId", "tags"]);
+    const out = Object.assign(Object.assign({}, rest), { messageFeedId: subChannelId, options: { token: toToken(page || { limit: 10 }, 'afterbeforeraw') } });
+    if (sortBy !== undefined) {
+        out.options.sortBy = sortBy;
+    }
+    if (tags) {
+        out.includeTags = tags;
+    }
+    return out;
+}
+
 /**
  * ```js
  * import { getMessage } from '@amityco/ts-sdk'
@@ -21542,7 +21642,9 @@ const getMessage = async (messageId, isLive = false) => {
     let data;
     try {
         // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/messages/${encodeURIComponent(messageId)}`);
+        const response = await client.http
+            .get(`/api/v5/messages/${encodeURIComponent(messageId)}`)
+            .then(convertResponseFromRaw);
         data = response.data;
     }
     catch (error) {
@@ -21555,7 +21657,7 @@ const getMessage = async (messageId, isLive = false) => {
     if (client.cache)
         ingestInCache(data, { cachedAt });
     const { messages } = data;
-    fireEvent('v3.message.didFetch', { messages });
+    fireEvent('local.message.fetched', { messages });
     return {
         data: messages.find(message => message.messageId === messageId),
         cachedAt,
@@ -21605,15 +21707,16 @@ getMessage.locally = (messageId) => {
 const getMessages = async (messageIds) => {
     const client = getActiveClient();
     client.log('message/getMessages', messageIds);
-    // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const { data } = await client.http.get(`/api/v3/messages/list`, {
-        params: { messageIds },
-    });
+    const { data } = await client.http
+        .get(`/api/v5/messages/list`, {
+        params: { messageIds: messageIds.map(encodeURIComponent) },
+    })
+        .then(convertResponseFromRaw);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
     const { messages } = data;
-    fireEvent('v3.message.didFetch', { messages });
+    fireEvent('local.message.fetched', { messages });
     return {
         data: messages,
         cachedAt,
@@ -21668,31 +21771,25 @@ getMessages.locally = (messageIds) => {
 const queryMessages = async (query) => {
     const client = getActiveClient();
     client.log('message/queryMessages', query);
-    const { page = { limit: 10 } } = query, params = __rest(query, ["page"]);
+    const params = convertQueryParams$1(query);
     // API-FIX: parameters should be querystring. (1)
     // API-FIX: backend should answer Amity.Response (2)
     // API-FIX: pagination should not be indexed on channelSegment (3)
     // const { data } = await client.http.get<Amity.Response<Amity.Paged<Amity.MessagePayload>>>(
-    const { data } = await client.http.get(`/api/v3/messages`, {
-        params: Object.assign(Object.assign({}, params), { options: {
-                token: toToken(page, 'afterbefore'),
-            } }),
-    });
+    const response = await client.http
+        .get(`/api/v5/messages`, { params })
+        .then(convertResponseFromRaw);
     // API-FIX: backend should answer Amity.Response (2)
     // const { paging, messages } = unwrapPayload(data)
-    const { paging } = data, payload = __rest(data, ["paging"]);
-    const { messages } = payload;
+    const _a = response.data, { paging } = _a, data = __rest(_a, ["paging"]);
+    const { messages } = data;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
-        ingestInCache(payload, { cachedAt });
-        const cacheKey = [
-            'message',
-            'query',
-            Object.assign(Object.assign({}, params), { options: Object.assign({}, page) }),
-        ];
+        ingestInCache(data, { cachedAt });
+        const cacheKey = ['message', 'query', params];
         pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });
     }
-    fireEvent('v3.message.didFetch', { messages });
+    fireEvent('local.message.fetched', { messages });
     const nextPage = toPage(paging.next);
     const prevPage = toPage(paging.previous);
     return { data: messages, cachedAt, prevPage, nextPage };
@@ -21716,8 +21813,8 @@ queryMessages.locally = (query) => {
     client.log('message/queryMessages.locally', query);
     if (!client.cache)
         return;
-    const { page = { limit: 10 } } = query, params = __rest(query, ["page"]);
-    const queryKey = ['message', 'query', Object.assign(Object.assign({}, params), { options: Object.assign({}, page) })];
+    const params = convertQueryParams$1(query);
+    const queryKey = ['message', 'query', params];
     const { data, cachedAt } = (_a = pullFromCache(queryKey)) !== null && _a !== void 0 ? _a : {};
     if (!(data === null || data === void 0 ? void 0 : data.messages.length))
         return;
@@ -21734,13 +21831,20 @@ queryMessages.locally = (query) => {
 
 const uuid = () => nativeIdGenerator__default["default"].v4().toString();
 
+// FIXME: temp solution
+let uniqueId;
 /**
  * ```js
- * import { createMessage } from '@amityco/ts-sdk'
- * const created = await createMessage({
- *   channelId: 'foobar',
- *   data: { text: 'hello world' }
- * })
+ * import { createMessage, createQuery, runQuery } from '@amityco/ts-sdk'
+ *
+ * const query = createQuery(createMessage, {
+ *   subChannelId: 'foobar',
+ *   data: { text: 'hello world' },
+ * });
+ *
+ * runQuery(query, ({ data: message, loading }) => {
+ *   console.log(message);
+ * });
  * ```
  *
  * Creates an {@link Amity.Message}
@@ -21753,13 +21857,19 @@ const uuid = () => nativeIdGenerator__default["default"].v4().toString();
  */
 const createMessage = async (bundle) => {
     const client = getActiveClient();
-    client.log('user/createMessage', bundle);
-    const { data } = await client.http.post('/api/v3/messages', bundle);
+    client.log('message/createMessage', bundle);
+    const referenceId = uniqueId;
+    uniqueId = undefined;
+    const { data } = await client.http
+        .post('/api/v5/messages', Object.assign(Object.assign({}, convertParams(bundle)), { referenceId }))
+        .then(convertResponseFromRaw);
     const cachedAt = client.cache && Date.now();
-    if (client.cache)
+    if (client.cache) {
+        dropFromCache(['message', 'get', referenceId]);
         ingestInCache(data, { cachedAt });
+    }
     const { messages } = data;
-    fireEvent('v3.message.didCreate', { messages });
+    fireEvent('local.message.created', { messages });
     return {
         data: messages[0],
         cachedAt,
@@ -21768,7 +21878,8 @@ const createMessage = async (bundle) => {
 /**
  * ```js
  * import { createMessage } from '@amityco/ts-sdk'
- * const created = createMessage.locally({
+ *
+ * const created = createMessage.optimistically({
  *   channelId: 'foobar',
  *   data: { text: 'hello world' }
  * })
@@ -21793,17 +21904,26 @@ createMessage.optimistically = (bundle) => {
      * Updated to handle client requirement to add messageId while uploading
      * message with image. Temporary!
      */
-    const bundleWithMessageId = Object.assign({ messageId: uuid() }, bundle);
-    // only log if cache is enabled
-    client.log('user/createMessage.locally', bundleWithMessageId);
-    const channel = pullFromCache(['channel', 'get', bundleWithMessageId.channelId]);
-    upsertInCache(['channel', 'get', bundleWithMessageId.channelId], Object.assign(Object.assign({}, channel === null || channel === void 0 ? void 0 : channel.data), { messageCount: ((_a = channel === null || channel === void 0 ? void 0 : channel.data.messageCount) !== null && _a !== void 0 ? _a : 0) + 1 }));
+    const localId = `LOCAL_${uuid()}`;
+    uniqueId = localId;
+    const bundleWithMessageId = Object.assign({ messageId: localId, uniqueId: localId }, bundle);
+    client.log('message/createMessage.optimistically', bundleWithMessageId);
+    const subChannel = pullFromCache(['subChannel', 'get', bundle.subChannelId]);
+    if (subChannel) {
+        upsertInCache(['subChannel', 'get', bundle.subChannelId], Object.assign(Object.assign({}, subChannel.data), { messageCount: subChannel.data.messageCount + 1 }));
+        if (subChannel.data.channelId === subChannel.data.subChannelId) {
+            const channel = pullFromCache(['channel', 'get', subChannel.data.channelId]);
+            if (channel === null || channel === void 0 ? void 0 : channel.data) {
+                upsertInCache(['channel', 'get', subChannel.data.channelId], Object.assign(Object.assign({}, channel.data), { messageCount: ((_a = channel.data.messageCount) !== null && _a !== void 0 ? _a : 0) + 1 }));
+            }
+        }
+    }
     // as reused to update created and updated time, which should be the same
     const createdTime = new Date().toISOString();
-    const message = Object.assign({ userId: client.userId, channelSegment: ((_b = channel === null || channel === void 0 ? void 0 : channel.data.messageCount) !== null && _b !== void 0 ? _b : 0) + 1, createdAt: createdTime, updatedAt: createdTime }, bundleWithMessageId);
+    const message = Object.assign({ creatorId: client.userId, channelSegment: ((_b = subChannel === null || subChannel === void 0 ? void 0 : subChannel.data.messageCount) !== null && _b !== void 0 ? _b : 0) + 1, childrenNumber: 0, createdAt: createdTime, updatedAt: createdTime }, bundleWithMessageId);
     const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
     pushToCache(['message', 'get', message.messageId], message, { cachedAt });
-    fireEvent('v3.message.didCreate', { messages: [message] });
+    fireEvent('local.message.created', { messages: [message] });
     return {
         cachedAt,
         data: message,
@@ -21829,13 +21949,15 @@ createMessage.optimistically = (bundle) => {
  */
 const updateMessage = async (messageId, patch) => {
     const client = getActiveClient();
-    client.log('user/updateMessage', patch);
-    const { data } = await client.http.put(`/api/v3/messages/${encodeURIComponent(messageId)}`, patch);
+    client.log('message/updateMessage', patch);
+    const { data } = await client.http
+        .put(`/api/v5/messages/${encodeURIComponent(messageId)}`, convertParams(patch))
+        .then(convertResponseFromRaw);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
     const { messages } = data;
-    fireEvent('v3.message.didUpdate', { messages });
+    fireEvent('local.message.updated', { messages });
     return {
         data: messages.find(message => message.messageId === messageId),
         cachedAt,
@@ -21844,7 +21966,7 @@ const updateMessage = async (messageId, patch) => {
 /**
  * ```js
  * import { updateMessage } from '@amityco/ts-sdk'
- * const updated = updateMessage.locally('foobar', {
+ * const updated = updateMessage.optimistically('foobar', {
  *   data: { text: 'hello world' }
  * })
  * ```
@@ -21859,7 +21981,7 @@ const updateMessage = async (messageId, patch) => {
  */
 updateMessage.optimistically = (messageId, patch) => {
     const client = getActiveClient();
-    client.log('user/updateMessage', patch);
+    client.log('message/updateMessage.optimistically', patch);
     if (!client.cache)
         return;
     const message = pullFromCache(['message', 'get', messageId]);
@@ -21868,7 +21990,7 @@ updateMessage.optimistically = (messageId, patch) => {
     const cachedAt = -1;
     const updated = Object.assign(Object.assign(Object.assign({}, message.data), patch), { updatedAt: new Date().toISOString() });
     upsertInCache(['message', 'get', messageId], updated, { cachedAt });
-    fireEvent('v3.message.didUpdate', { messages: [updated] });
+    fireEvent('local.message.updated', { messages: [updated] });
     return {
         data: updated,
         cachedAt,
@@ -21883,7 +22005,7 @@ updateMessage.optimistically = (messageId, patch) => {
  *
  * Delete a {@link Amity.Message}
  *
- * @param The ID of the {@link Amity.Message} to delete
+ * @param messageId the ID of the {@link Amity.Message} to delete
  * @return A success boolean if the {@link Amity.Message} was deleted
  *
  * @category Message API
@@ -21893,15 +22015,15 @@ const deleteMessage = async (messageId) => {
     const client = getActiveClient();
     client.log('message/deleteMessage', messageId);
     // API-FIX: This endpoint has not been implemented yet.
-    await client.http.delete(`/api/v3/messages/${encodeURIComponent(messageId)}`);
+    await client.http.delete(`/api/v5/messages/${encodeURIComponent(messageId)}`);
     const deleted = await getMessage(messageId);
-    fireEvent('v3.message.didDelete', { messages: [deleted.data] });
+    fireEvent('local.message.deleted', { messages: [deleted.data] });
     return deleted.data;
 };
 /**
  * ```js
  * import { deleteMessage } from '@amityco/ts-sdk'
- * const success = deleteMessage.locally('foobar')
+ * const success = deleteMessage.optimistically('foobar')
  * ```
  *
  * Deletes a {@link Amity.Message}
@@ -21913,14 +22035,14 @@ const deleteMessage = async (messageId) => {
  */
 deleteMessage.optimistically = (messageId) => {
     const client = getActiveClient();
-    client.log('message/deleteMessage', messageId);
+    client.log('message/deleteMessage.optimistically', messageId);
     const message = pullFromCache(['message', 'get', messageId]);
     if (!message)
         return;
     const cachedAt = -1;
     const deleted = Object.assign(Object.assign({}, message.data), { isDeleted: true, updatedAt: new Date().toISOString() });
     upsertInCache(['message', 'get', messageId], deleted, { cachedAt });
-    fireEvent('v3.message.didDelete', { messages: [deleted] });
+    fireEvent('local.message.deleted', { messages: [deleted] });
     return {
         data: deleted,
         cachedAt,
@@ -21945,11 +22067,20 @@ const queryPosts = async (query) => {
     const client = getActiveClient();
     client.log('post/queryPosts', query);
     const { page = { limit: 10 } } = query, params = __rest(query, ["page"]);
+    const { dataTypes, matchingOnlyParentPost } = params;
     // API-FIX: parameters should be querystring. (1)
     // API-FIX: backend should answer Amity.Response (2)
     // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<Amity.PostPayload>>>(
     const { data } = await client.http.get(`/api/v4/posts`, {
-        params: Object.assign(Object.assign({}, params), { options: {
+        params: Object.assign(Object.assign({}, params), { 
+            /*
+             * when creating post like image, file, video BE will create 2 posts
+             * 1. parent post to store text with dataType=text
+             * 2. child post to store dataTypes post data
+             *
+             * By default BE queries only parent post
+             */
+            matchingOnlyParentPost: matchingOnlyParentPost !== null && matchingOnlyParentPost !== void 0 ? matchingOnlyParentPost : !(dataTypes === null || dataTypes === void 0 ? void 0 : dataTypes.length), options: {
                 token: toToken(page, 'afterbeforeraw'),
             } }),
     });
@@ -22247,12 +22378,13 @@ const queryCommunities = async (query) => {
     const client = getActiveClient();
     client.log('channel/queryCommunities', query);
     // safe decapsulation
-    const _a = query !== null && query !== void 0 ? query : {}, { page, displayName, membership } = _a, params = __rest(_a, ["page", "displayName", "membership"]);
+    const _a = query !== null && query !== void 0 ? query : {}, { page } = _a, params = __rest(_a, ["page"]);
+    const _b = params !== null && params !== void 0 ? params : {}, { displayName, membership } = _b, restParams = __rest(_b, ["displayName", "membership"]);
     // API-FIX: parameters should be querystring.
     // API-FIX: backend doesnt answer Amity.Response
     // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<CommunityPayload>>>(
     const { data } = await client.http.get(`/api/v3/communities`, {
-        params: Object.assign(Object.assign({}, params), { keyword: displayName, filter: membership, options: {
+        params: Object.assign(Object.assign({}, restParams), { keyword: displayName, filter: membership, options: {
                 token: toToken(page, 'skiplimit'),
             } }),
     });
@@ -22547,6 +22679,58 @@ const leaveCommunity = async (communityId) => {
     return !!communityUsers.find(communityUser => communityUser.communityId === communityId && communityUser.communityMembership !== 'member');
 };
 
+/**
+ * Attach user object to membership model
+ * - If cache is not enabled, set user to undefined ({..., user: undefined})
+ * - If user object is not found in cache, set user to undefined
+ * ({..., user: undefined})
+ * - If a user is found in the cache, it attaches the user from the cache
+ * ({..., user: { userId, displayName,... }})
+ *
+ * @param member The membership model object
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The membership model object that is already mapped to user
+ * @hidden
+ */
+const withUser = (member, userIdProp = 'userId', userProp = 'user') => (Object.assign({ get [userProp]() {
+        var _a;
+        const client = getActiveClient();
+        if (!client.cache)
+            return undefined;
+        const userCache = (_a = pullFromCache(['user', 'get', member[userIdProp]])) === null || _a === void 0 ? void 0 : _a.data;
+        if (!userCache) {
+            return undefined;
+        }
+        return userCache;
+    } }, member));
+/**
+ * Mapping membership model with user object
+ *
+ * @param members The membership model objects
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The membership model objects that is already
+ * mapped to users
+ * @hidden
+ */
+const withUsers = (members, userIdProp = 'userId', userProp = 'user') => members.map(member => withUser(member, userIdProp, userProp));
+/**
+ * Transform members prop in any payload with attached users members
+ *
+ * @param payload The payload contain members prop
+ * @param memberProp A name of members prop
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The transforming payload
+ * @hidden
+ */
+const prepareMembershipPayload = (payload, memberProp, userIdProp = 'userId', userProp = 'user') => {
+    const _a = payload, _b = memberProp, memberPayload = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+    const members = withUsers(memberPayload, userIdProp, userProp);
+    return Object.assign(Object.assign({}, rest), { [memberProp]: members });
+};
+
 /**
  * ```js
  * import { queryCommunityMembers } from '@amityco/ts-sdk'
@@ -22564,17 +22748,27 @@ const leaveCommunity = async (communityId) => {
 const queryCommunityMembers = async (query) => {
     const client = getActiveClient();
     client.log('community/queryCommunityMembers', query);
-    const _a = query !== null && query !== void 0 ? query : {}, { page, communityId } = _a, params = __rest(_a, ["page", "communityId"]);
-    const { data } = await client.http.get(`/api/v3/communities/${communityId}/users`, {
+    const _a = query !== null && query !== void 0 ? query : {}, { page } = _a, params = __rest(_a, ["page"]);
+    const { data: queryPayload } = await client.http.get(`/api/v3/communities/${params.communityId}/users`, {
         params: Object.assign(Object.assign({}, params), { options: {
                 token: toToken(page, 'skiplimit'),
             } }),
     });
-    const { paging } = data, payload = __rest(data, ["paging"]);
-    const { communityUsers } = payload;
+    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
+    const preparedPayload = prepareMembershipPayload(payload, 'communityUsers');
+    const { communityUsers } = preparedPayload;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
-        ingestInCache(payload, { cachedAt });
+        ingestInCache(preparedPayload, { cachedAt });
+        const cacheKey = [
+            'communityUsers',
+            'query',
+            Object.assign(Object.assign({}, params), { options: Object.assign({}, page) }),
+        ];
+        pushToCache(cacheKey, {
+            communityUsers: communityUsers.map(({ communityId, userId }) => getResolver('communityUsers')({ communityId, userId })),
+            paging,
+        });
     }
     const nextPage = toPage(paging.next);
     const prevPage = toPage(paging.previous);
@@ -22594,9 +22788,29 @@ const queryCommunityMembers = async (query) => {
  * @category Post API
  */
 queryCommunityMembers.locally = (query) => {
+    var _a, _b;
     const client = getActiveClient();
     client.log('community/queryCommunityMembers', query);
-    // TODO
+    if (!client.cache)
+        return;
+    const _c = query !== null && query !== void 0 ? query : {}, { page } = _c, params = __rest(_c, ["page"]);
+    const cacheKey = [
+        'communityUsers',
+        'query',
+        Object.assign(Object.assign({}, params), { options: Object.assign({}, page) }),
+    ];
+    const { data, cachedAt } = (_a = pullFromCache(cacheKey)) !== null && _a !== void 0 ? _a : {};
+    if (!(data === null || data === void 0 ? void 0 : data.communityUsers.length))
+        return;
+    const communityUsers = data.communityUsers
+        .map(key => pullFromCache(['communityUsers', 'get', key]))
+        .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);
+    return communityUsers.length === ((_b = data === null || data === void 0 ? void 0 : data.communityUsers) === null || _b === void 0 ? void 0 : _b.length)
+        ? { data: communityUsers, cachedAt, prevPage, nextPage }
+        : undefined;
 };
 
 /**
@@ -23305,38 +23519,6 @@ const preparePayloadForCache = (event, payload) => {
     }
 };
 
-/** @hidden */
-/*
- * @param message payload from http request without myReactions
- * add myReactions to http response if the event was a reaction event
- */
-const prepareMessagePayloadForCache = (payload) => {
-    const client = getActiveClient();
-    const cached = pullFromCache(['message', 'get', payload.messageId]);
-    // '[]' in cases where the new reaction is the first one
-    const myReactions = (cached === null || cached === void 0 ? void 0 : cached.data.myReactions) || [];
-    // add myReactions to the payload
-    Object.assign(payload, { myReactions });
-    // check if there are any updates to the reactions
-    const latestReaction = payload === null || payload === void 0 ? void 0 : payload.latestReaction;
-    const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
-    if (!isLatestReactionMine) {
-        return;
-    }
-    // new reaction added
-    if (latestReaction.eventName === 'add' && !myReactions.includes(latestReaction.reactionName)) {
-        Object.assign(payload, {
-            myReactions: [...myReactions, latestReaction.reactionName],
-        });
-    }
-    // existing reaction removed
-    if (latestReaction.eventName === 'remove' && myReactions.includes(latestReaction.reactionName)) {
-        Object.assign(payload, {
-            myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
-        });
-    }
-};
-
 /**
  * ```js
  * import { addReaction } from '@amityco/ts-sdk'
@@ -23364,6 +23546,7 @@ const addReaction = async (referenceType, referenceId, reactionName) => {
         referenceId,
         referenceType,
         reactionName,
+        referenceVersion: referenceType === 'message' ? 5 : undefined,
     });
     if (client.cache) {
         const model = pullFromCache([
@@ -23440,7 +23623,12 @@ const removeReaction = async (referenceType, referenceId, reactionName) => {
         reactionName,
     });
     await client.http.delete(`/api/v2/reactions`, {
-        data: { referenceId, referenceType, reactionName },
+        data: {
+            referenceId,
+            referenceType,
+            reactionName,
+            referenceVersion: referenceType === 'message' ? 5 : undefined,
+        },
     });
     if (client.cache) {
         const model = pullFromCache([
@@ -23953,8 +24141,9 @@ const onReactionAdded = (referenceType, referenceId, callback) => {
      */
     if (referenceType === 'message') {
         const client = getActiveClient();
-        const filter = (payload) => {
+        const filter = (rawPayload) => {
             var _a;
+            const payload = prepareMessagePayload(rawPayload);
             const cached = pullFromCache([
                 'message',
                 'get',
@@ -23966,7 +24155,7 @@ const onReactionAdded = (referenceType, referenceId, callback) => {
                 callbackWrapper(payload.messages[0]);
             }
         };
-        return createEventSubscriber(client, 'reaction/onReactionAdded', 'v3.message.didUpdate', filter);
+        return createEventSubscriber(client, 'reaction/onReactionAdded', 'message.updated', filter);
     }
     if (referenceType === 'post') {
         return onPostReactionAdded(callbackWrapper);
@@ -23999,8 +24188,9 @@ const onReactionRemoved = (referenceType, referenceId, callback) => {
     };
     if (referenceType === 'message') {
         const client = getActiveClient();
-        const filter = (payload) => {
+        const filter = (rawPayload) => {
             var _a;
+            const payload = prepareMessagePayload(rawPayload);
             const cached = pullFromCache([
                 'message',
                 'get',
@@ -24012,7 +24202,7 @@ const onReactionRemoved = (referenceType, referenceId, callback) => {
                 callbackWrapper(payload.messages[0]);
             }
         };
-        return createEventSubscriber(client, 'reaction/onReactionRemoved', 'v3.message.didUpdate', filter);
+        return createEventSubscriber(client, 'reaction/onReactionRemoved', 'message.updated', filter);
     }
     if (referenceType === 'post') {
         return onPostReactionRemoved(callbackWrapper);
@@ -24045,7 +24235,8 @@ const onReactorAdded = (referenceType, referenceId, callback) => {
         }
     };
     if (referenceType === 'message') {
-        const filter = (payload) => {
+        const filter = (rawPayload) => {
+            const payload = prepareMessagePayload(rawPayload);
             if (!payload.messages[0].latestReaction)
                 return;
             const _a = payload.messages[0].latestReaction, { eventName, referenceId, referenceType, userDisplayName } = _a, reactor = __rest(_a, ["eventName", "referenceId", "referenceType", "userDisplayName"]);
@@ -24055,7 +24246,7 @@ const onReactorAdded = (referenceType, referenceId, callback) => {
             ingestInCache({ reactions: [reactor] });
             callbackWrapper('message', payload.messages[0].messageId, reactor);
         };
-        return createEventSubscriber(client, 'reaction/onReactorAdded', 'v3.message.didUpdate', filter);
+        return createEventSubscriber(client, 'reaction/onReactorAdded', 'message.updated', filter);
     }
     if (referenceType === 'post') {
         const filter = (payload) => {
@@ -24100,7 +24291,8 @@ const onReactorRemoved = (referenceType, referenceId, callback) => {
         }
     };
     if (referenceType === 'message') {
-        const filter = (payload) => {
+        const filter = (rawPayload) => {
+            const payload = prepareMessagePayload(rawPayload);
             if (!payload.messages[0].latestReaction)
                 return;
             const _a = payload.messages[0].latestReaction, { eventName, referenceId, referenceType } = _a, reactor = __rest(_a, ["eventName", "referenceId", "referenceType"]);
@@ -24110,7 +24302,7 @@ const onReactorRemoved = (referenceType, referenceId, callback) => {
             ingestInCache({ reactions: [reactor] });
             callbackWrapper('message', payload.messages[0].messageId, reactor);
         };
-        return createEventSubscriber(client, 'reaction/onReactorRemoved', 'v3.message.didUpdate', filter);
+        return createEventSubscriber(client, 'reaction/onReactorRemoved', 'message.updated', filter);
     }
     if (referenceType === 'post') {
         const filter = (payload) => {
@@ -24180,7 +24372,7 @@ const liveReactions = (params, callback, config) => {
             error: data.error,
         });
     };
-    const realtimeRouter = (reaction, action) => {
+    const realtimeRouter = (action) => (reaction) => {
         var _a;
         const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
         if (!collection)
@@ -24217,7 +24409,7 @@ const liveReactions = (params, callback, config) => {
             responder(data);
         }, queryOptions(policy));
     };
-    disposers.push(onReactorAdded(queryParams.referenceType, queryParams.referenceId, reaction => realtimeRouter(reaction, 'onAdded')), onReactorRemoved(queryParams.referenceType, queryParams.referenceId, reaction => realtimeRouter(reaction, 'onRemoved')));
+    disposers.push(onReactorAdded(queryParams.referenceType, queryParams.referenceId, realtimeRouter('onAdded')), onReactorRemoved(queryParams.referenceType, queryParams.referenceId, realtimeRouter('onRemoved')));
     onFetch();
     return () => {
         log(`liveReactions(tmpid: ${timestamp}) > dispose`);
@@ -24264,16 +24456,26 @@ var REFERENCE_TYPES = {
 const createReport = async (referenceType, referenceId) => {
     const client = getActiveClient();
     client.log('report/createReport', { referenceType, referenceId });
-    const { domainName } = REFERENCE_TYPES[referenceType];
-    const { data } = await client.http.post(`/api/${referenceType === 'user'
-        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
-        : `v3/${domainName}/${encodeURIComponent(referenceId)}/flag`}`);
+    const getAPIUrl = () => {
+        if (referenceType === 'user') {
+            return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
+        }
+        if (referenceType === 'message') {
+            return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
+        }
+        const { domainName } = REFERENCE_TYPES[referenceType];
+        return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`;
+    };
+    const { data } = await client.http.post(getAPIUrl());
     if (client.cache)
-        ingestInCache(data);
-    const event = referenceType === 'message'
-        ? 'v3.message.didUpdate'
-        : `${referenceType}.flagged`;
-    fireEvent(event, data);
+        ingestInCache(referenceType === 'message' ? prepareMessagePayload(data) : data);
+    if (referenceType === 'message') {
+        fireEvent('message.flagged', data);
+    }
+    else {
+        // @ts-ignore
+        fireEvent(`${referenceType}.flagged`, data);
+    }
     return !!data;
 };
 
@@ -24293,17 +24495,27 @@ const createReport = async (referenceType, referenceId) => {
 const deleteReport = async (referenceType, referenceId) => {
     const client = getActiveClient();
     client.log('report/deleteReport', { referenceType, referenceId });
-    const { domainName } = REFERENCE_TYPES[referenceType];
-    const { data } = await client.http.delete(`/api/${referenceType === 'user'
-        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
-        : `v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`}`);
+    const getAPIUrl = () => {
+        if (referenceType === 'user') {
+            return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
+        }
+        if (referenceType === 'message') {
+            return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
+        }
+        const { domainName } = REFERENCE_TYPES[referenceType];
+        return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`;
+    };
+    const { data } = await client.http.delete(getAPIUrl());
     if (client.cache)
-        ingestInCache(data);
-    const event = referenceType === 'message'
-        ? 'v3.message.didUpdate'
-        : `${referenceType}.unflagged`;
-    fireEvent(event, data);
-    return !!data;
+        ingestInCache(referenceType === 'message' ? prepareMessagePayload(data) : data);
+    if (referenceType === 'message') {
+        fireEvent('message.unflagged', data);
+    }
+    else {
+        // @ts-ignore
+        fireEvent(`${referenceType}.unflagged`, data);
+    }
+    return !!data;
 };
 
 /**
@@ -24324,26 +24536,45 @@ const isReportedByMe = async (referenceType, referenceId) => {
     const client = getActiveClient();
     client.log('report/isReportedByMe', { referenceType, referenceId });
     const { eventName, primaryKey } = REFERENCE_TYPES[referenceType];
+    if (referenceType === 'message') {
+        const { data } = await client.http.get(`/api/v5/messages/${encodeURIComponent(referenceId)}/flags`);
+        return data.result;
+    }
     const { result, isFlagByMe } = (_a = (await synchronousWSCall(client, eventName, {
         [primaryKey]: referenceId,
     }))) !== null && _a !== void 0 ? _a : {};
     return (_b = result !== null && result !== void 0 ? result : isFlagByMe) !== null && _b !== void 0 ? _b : false;
 };
 
-/** @hidden */
+function convertFromRaw$1(_a, params) {
+    var { _id } = _a, rest = __rest(_a, ["_id"]);
+    return Object.assign(Object.assign(Object.assign({}, rest), params), { defaultSubChannelId: _id });
+}
+function getSegmentParams(rawChannel) {
+    let cached;
+    try {
+        cached = pullFromCache(['channel', 'get', rawChannel.channelId]);
+        // eslint-disable-next-line no-empty
+    }
+    catch (_a) { }
+    if (cached) {
+        return {
+            defaultSubChannelHasUnreadMention: cached.data.defaultSubChannelHasUnreadMention,
+            defaultSubChannelUnreadCount: cached.data.defaultSubChannelUnreadCount,
+            localReadToSegment: cached.data.localReadToSegment,
+            localLastMentionSegment: cached.data.localLastMentionSegment,
+        };
+    }
+    return {
+        defaultSubChannelHasUnreadMention: false,
+        defaultSubChannelUnreadCount: 0,
+        // @ts-ignore
+        localReadToSegment: rawChannel.messageCount > 0 ? rawChannel.messageCount - 1 : 0,
+        localLastMentionSegment: 0,
+    };
+}
 const prepareChannelPayload = (payload) => {
-    const client = getActiveClient();
-    const channels = payload.channels.map(channel => {
-        const channelUser = payload.channelUsers.find(channelUser => channelUser.userId === client.userId && channel.channelId === channelUser.channelId);
-        const hasMention = channelUser
-            ? channelUser.readToSegment < channelUser.lastMentionedSegment
-            : false;
-        const unreadCount = channelUser && channelUser.membership === 'member' && channel.messageCount
-            ? Math.max(0, channel.messageCount - channelUser.readToSegment)
-            : 0;
-        return Object.assign(Object.assign({}, channel), { hasMention,
-            unreadCount });
-    });
+    const channels = payload.channels.map(channel => convertFromRaw$1(channel, getSegmentParams(channel)));
     return Object.assign(Object.assign({}, payload), { channels });
 };
 
@@ -24479,10 +24710,10 @@ getChannels.locally = (channelIds) => {
     const cached = channelIds
         .map(channelId => pullFromCache(['channel', 'get', channelId]))
         .filter(Boolean);
-    const channels = cached.map(({ data }) => data);
-    const oldest = (_a = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _a === void 0 ? void 0 : _a[0];
     if ((cached === null || cached === void 0 ? void 0 : cached.length) < channelIds.length)
         return;
+    const channels = cached.map(({ data }) => data);
+    const oldest = (_a = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _a === void 0 ? void 0 : _a[0];
     return {
         data: channels,
         cachedAt: oldest.cachedAt,
@@ -24557,7 +24788,7 @@ getChannel.locally = (channelId) => {
 /**
  * ```js
  * import { createChannel } from '@amityco/ts-sdk'
- * const created = await createChannel({ channelId: 'foobar', displayName: 'foobar' })
+ * const created = await createChannel({ displayName: 'foobar' })
  * ```
  *
  * Creates an {@link Amity.Channel}
@@ -24709,18 +24940,19 @@ const leaveChannel = async (channelId) => {
 const queryChannelMembers = async (query) => {
     const client = getActiveClient();
     client.log('channel/queryChannelMembers', query);
-    const _a = query !== null && query !== void 0 ? query : {}, { page = { limit: 10 } } = _a, params = __rest(_a, ["page"]);
+    const _a = query !== null && query !== void 0 ? query : {}, { page } = _a, params = __rest(_a, ["page"]);
     const { data: queryPayload } = await client.http.get(`/api/v4/channels/${encodeURIComponent(params.channelId)}/users`, {
         params: Object.assign(Object.assign({}, params), { options: {
                 token: toToken(page, 'skiplimit'),
             } }),
     });
     const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
-    const data = prepareChannelPayload(payload);
-    const { channelUsers } = data;
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channelUsers } = preparedPayload;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
-        ingestInCache(data);
+        ingestInCache(preparedPayload);
         const cacheKey = [
             'channelUsers',
             'query',
@@ -24733,7 +24965,12 @@ const queryChannelMembers = async (query) => {
     }
     const nextPage = toPage(paging.next);
     const prevPage = toPage(paging.previous);
-    return { data: channelUsers, cachedAt, nextPage, prevPage };
+    return {
+        data: channelUsers,
+        cachedAt,
+        nextPage,
+        prevPage,
+    };
 };
 /**
  * ```js
@@ -24754,7 +24991,7 @@ queryChannelMembers.locally = (query) => {
     client.log('channel/queryChannelMembers.locally', query);
     if (!client.cache)
         return;
-    const { page = { limit: 10 } } = query, params = __rest(query, ["page"]);
+    const { page } = query, params = __rest(query, ["page"]);
     const cacheKey = [
         'channelUsers',
         'query',
@@ -24800,7 +25037,7 @@ const addChannelMembers = async (channelId, userIds) => {
     /*
      * should fire event for each user that was added
      */
-    userIds.forEach(id => fireEvent('v3.channel.didAddUsers', Object.assign(Object.assign({}, data), { channelUsers: data.channelUsers.filter(u => u.userId === id) })));
+    userIds.forEach(id => fireEvent('channel.membersAdded', Object.assign(Object.assign({}, payload), { channelUsers: data.channelUsers.filter(u => u.userId === id) })));
     const { channelUsers } = data;
     return !!channelUsers.find(channelUser => channelUser.channelId === channelId && channelUser.membership === 'member');
 };
@@ -24827,7 +25064,10 @@ const removeChannelMembers = async (channelId, userIds) => {
     const data = prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
-    fireEvent('v3.channel.didRemoveUsers', data);
+    /*
+     * should fire event for each user that was removed
+     */
+    userIds.forEach(id => fireEvent('channel.membersRemoved', Object.assign(Object.assign({}, payload), { channelUsers: data.channelUsers.filter(u => u.userId === id) })));
     const { channelUsers } = data;
     return !!channelUsers.find(channelUser => channelUser.channelId === channelId && channelUser.membership !== 'member');
 };
@@ -24906,11 +25146,12 @@ const banChannelMembers = async (channelId, userIds) => {
     const { data: payload } = await client.http.put(`/api/v3/channels/${channelId}/users/ban`, {
         userIds,
     });
-    const data = prepareChannelPayload(payload);
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channelUsers } = preparedPayload;
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { channelUsers } = data;
+        ingestInCache(preparedPayload, { cachedAt });
     return {
         data: channelUsers === null || channelUsers === void 0 ? void 0 : channelUsers.filter(user => user.membership === 'banned'),
         cachedAt,
@@ -24937,17 +25178,92 @@ const unbanChannelMembers = async (channelId, userIds) => {
     const { data: payload } = await client.http.put(`/api/v3/channels/${encodeURIComponent(channelId)}/users/unban`, {
         userIds,
     });
-    const data = prepareChannelPayload(payload);
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { channelUsers } = data;
+        ingestInCache(preparedPayload, { cachedAt });
+    const { channelUsers } = preparedPayload;
     return {
         data: channelUsers === null || channelUsers === void 0 ? void 0 : channelUsers.filter(user => user.membership === 'member'),
         cachedAt,
     };
 };
 
+/**
+ * ```js
+ * import { startReading } from '@amityco/ts-sdk'
+ * const success = await startReading('foo')
+ * ```
+ *
+ * Mark all messages as read and start reading message inside channel
+ *
+ * @param {string} subChannelId - The channel ID to start reading.
+ * @param {string} userId - The user ID of channel member.
+ * @return {Promise<boolean>>} A success boolean if the channel reading of the sub channel had begun.
+ *
+ * @category Message API
+ * @async
+ */
+const startReading = async (subChannelId, userId = getActiveClient().userId) => {
+    const client = getActiveClient();
+    client.log('message/startReading', { subChannelId });
+    const subChannel = pullFromCache(['subChannel', 'get', subChannelId]);
+    if (!subChannel) {
+        return;
+    }
+    const { channelId } = subChannel.data;
+    const channel = pullFromCache(['channel', 'get', channelId]);
+    if (!channel || channel.data.defaultSubChannelId !== subChannelId) {
+        return;
+    }
+    const update = Object.assign(Object.assign({}, channel.data), { 
+        // @ts-ignore
+        localReading: true, defaultSubChannelUnreadCount: 0, defaultSubChannelHasUnreadMention: false });
+    pushToCache(['channel', 'get', channelId], update);
+    client.emitter.emit('local.channel.updated', { channels: [update] });
+    const result = await synchronousWSCall(client, 'channel.startReading', {
+        channelId,
+    });
+    return !!result;
+};
+
+/**
+ * ```js
+ * import { stopReading } from '@amityco/ts-sdk'
+ * const success = await stopReading('foo')
+ * ```
+ *
+ * Stop reading message inside channel
+ *
+ * @param {string} subChannelId - The channel ID to stop reading.
+ * @return {Promise<boolean>>} A success boolean if the sub channel reading was halted.
+ *
+ * @category Message API
+ * @async
+ */
+const stopReading = async (subChannelId) => {
+    const client = getActiveClient();
+    client.log('message/stopReading', { subChannelId });
+    const subChannel = pullFromCache(['subChannel', 'get', subChannelId]);
+    if (!subChannel) {
+        return;
+    }
+    const { channelId } = subChannel.data;
+    const channel = pullFromCache(['channel', 'get', channelId]);
+    if (!channel || channel.data.defaultSubChannelId !== subChannelId) {
+        return;
+    }
+    const update = Object.assign(Object.assign({}, channel.data), { 
+        // @ts-ignore
+        localReading: false });
+    pushToCache(['channel', 'get', channelId], update);
+    const result = await synchronousWSCall(client, 'channel.stopReading', {
+        channelId,
+    });
+    return !!result;
+};
+
 /**
  * ```js
  * import { onChannelCreated } from '@amityco/ts-sdk'
@@ -24970,7 +25286,7 @@ const onChannelCreated = (callback) => {
         ingestInCache(data);
         callback(data.channels[0]);
     };
-    return createEventSubscriber(client, 'onChannelCreated', 'v3.channel.didCreate', filter);
+    return createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
 };
 
 /**
@@ -24995,7 +25311,13 @@ const onChannelUpdated = (callback) => {
         ingestInCache(data);
         callback(data.channels[0]);
     };
-    return createEventSubscriber(client, 'onChannelUpdated', 'v3.channel.didUpdate', filter);
+    const disposers = [
+        createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter),
+        createEventSubscriber(client, 'local.channel.updated', 'local.channel.updated', payload => callback(payload.channels[0])),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
 };
 
 /**
@@ -25020,13 +25342,13 @@ const onChannelDeleted = (callback) => {
         ingestInCache(data);
         callback(data.channels[0]);
     };
-    return createEventSubscriber(client, 'onChannelDeleted', 'v3.channel.didDelete', filter);
+    return createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
 };
 
 /**
  * ```js
  * import { onChannelJoined } from '@amityco/ts-sdk'
- * const dispose = onChannelJoined(channel => {
+ * const dispose = onChannelJoined((channel, member) => {
  *   // ...
  * })
  * ```
@@ -25041,17 +25363,19 @@ const onChannelDeleted = (callback) => {
 const onChannelJoined = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        const data = prepareChannelPayload(payload);
-        ingestInCache(data);
-        callback(data.channels[0]);
+        const channelPayload = prepareChannelPayload(payload);
+        const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+        const { channels, channelUsers } = preparedPayload;
+        ingestInCache(preparedPayload);
+        callback(channels[0], channelUsers[0]);
     };
-    return createEventSubscriber(client, 'onChannelJoined', 'v3.channel.didJoin', filter);
+    return createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
 };
 
 /**
  * ```js
  * import { onChannelLeft } from '@amityco/ts-sdk'
- * const dispose = onChannelLeft(channel => {
+ * const dispose = onChannelLeft((channel, member) => {
  *   // ...
  * })
  * ```
@@ -25064,13 +25388,40 @@ const onChannelJoined = (callback) => {
  * @category Channel Events
  */
 const onChannelLeft = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        const channelPayload = prepareChannelPayload(payload);
+        const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+        const { channels, channelUsers } = preparedPayload;
+        ingestInCache(preparedPayload);
+        callback(channels[0], channelUsers[0]);
+    };
+    return createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
+};
+
+/**
+ * ```js
+ * import { onChannelMuted } from '@amityco/ts-sdk'
+ * const dispose = onChannelMuted(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} have been muted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelMuted = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
         const data = prepareChannelPayload(payload);
         ingestInCache(data);
         callback(data.channels[0]);
     };
-    return createEventSubscriber(client, 'onChannelLeft', 'v3.channel.didLeave', filter);
+    return createEventSubscriber(client, 'onChannelMuted', 'channel.setMuted', filter);
 };
 
 /**
@@ -25091,11 +25442,13 @@ const onChannelLeft = (callback) => {
 const onChannelMemberAdded = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        const data = prepareChannelPayload(payload);
-        ingestInCache(data);
-        callback(data.channels[0], data.channelUsers[0]);
+        const channelPayload = prepareChannelPayload(payload);
+        const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+        const { channels, channelUsers } = preparedPayload;
+        ingestInCache(preparedPayload);
+        callback(channels[0], channelUsers.find(cu => cu.membership === 'member'));
     };
-    return createEventSubscriber(client, 'onChannelMemberAdded', 'v3.channel.didAddUsers', filter);
+    return createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
 };
 
 /**
@@ -25116,11 +25469,13 @@ const onChannelMemberAdded = (callback) => {
 const onChannelMemberRemoved = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        const data = prepareChannelPayload(payload);
-        ingestInCache(data);
-        callback(data.channels[0], data.channelUsers[0]);
+        const channelPayload = prepareChannelPayload(payload);
+        const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+        const { channels, channelUsers } = preparedPayload;
+        ingestInCache(preparedPayload);
+        callback(channels[0], channelUsers[0]);
     };
-    return createEventSubscriber(client, 'onChannelMemberRemoved', 'v3.channel.didRemoveUsers', filter);
+    return createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
 };
 
 /**
@@ -25141,11 +25496,13 @@ const onChannelMemberRemoved = (callback) => {
 const onChannelMemberBanned = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        const data = prepareChannelPayload(payload);
-        ingestInCache(data);
-        callback(data.channels[0], data.channelUsers.find(cu => cu.membership === 'banned'));
+        const channelPayload = prepareChannelPayload(payload);
+        const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+        const { channels, channelUsers } = preparedPayload;
+        ingestInCache(preparedPayload);
+        callback(channels[0], channelUsers.find(cu => cu.membership === 'banned'));
     };
-    return createEventSubscriber(client, 'onChannelMemberBanned', 'v3.channel.didBan', filter);
+    return createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
 };
 
 /**
@@ -25166,11 +25523,13 @@ const onChannelMemberBanned = (callback) => {
 const onChannelMemberUnbanned = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        const data = prepareChannelPayload(payload);
-        ingestInCache(data);
-        callback(data.channels[0], data.channelUsers.find(cu => cu.membership === 'none'));
+        const channelPayload = prepareChannelPayload(payload);
+        const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+        const { channels, channelUsers } = preparedPayload;
+        ingestInCache(preparedPayload);
+        callback(channels[0], channelUsers.find(cu => cu.membership === 'none'));
     };
-    return createEventSubscriber(client, 'onChannelMemberBanned', 'v3.channel.didUnban', filter);
+    return createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
 };
 
 /**
@@ -25206,7 +25565,7 @@ const observeChannel = (channelId, callback) => {
         (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
     };
     const disposers = [];
-    disposers.push(onChannelUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')), onChannelDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')), onChannelJoined(data => router({ data, loading: false, origin: 'event' }, 'onJoin')), onChannelLeft(data => router({ data, loading: false, origin: 'event' }, 'onLeft')), onChannelMemberAdded(data => router({ data, loading: false, origin: 'event' }, 'onMemberAdded')), onChannelMemberRemoved(data => router({ data, loading: false, origin: 'event' }, 'onMemberRemoved')));
+    disposers.push(onChannelUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')), onChannelDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')), onChannelJoined(data => router({ data, loading: false, origin: 'event' }, 'onJoin')), onChannelLeft(data => router({ data, loading: false, origin: 'event' }, 'onLeft')), onChannelMuted(data => router({ data, loading: false, origin: 'event' }, 'onMute')), onChannelMemberAdded(data => router({ data, loading: false, origin: 'event' }, 'onMemberAdded')), onChannelMemberRemoved(data => router({ data, loading: false, origin: 'event' }, 'onMemberRemoved')));
     runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));
     return () => {
         log(`observeChannel(tmpid: ${timestamp}) > dispose`);
@@ -25241,324 +25600,1131 @@ const observeChannels = (callback) => {
         (_a = callback.onEvent) === null || _a === void 0 ? void 0 : _a.call(callback, action, channel);
         (_b = callback[action]) === null || _b === void 0 ? void 0 : _b.call(callback, channel);
     };
-    disposers.push(onChannelCreated(data => router(data, 'onCreate')), onChannelUpdated(data => router(data, 'onUpdate')), onChannelDeleted(data => router(data, 'onDelete')), onChannelJoined(data => router(data, 'onJoin')), onChannelLeft(data => router(data, 'onLeft')), onChannelMemberAdded(data => router(data, 'onMemberAdded')), onChannelMemberRemoved(data => router(data, 'onMemberRemoved')));
+    disposers.push(onChannelCreated(data => router(data, 'onCreate')), onChannelUpdated(data => router(data, 'onUpdate')), onChannelDeleted(data => router(data, 'onDelete')), onChannelJoined(data => router(data, 'onJoin')), onChannelLeft(data => router(data, 'onLeft')), onChannelMuted(data => router(data, 'onMute')), onChannelMemberAdded(data => router(data, 'onMemberAdded')), onChannelMemberRemoved(data => router(data, 'onMemberRemoved')));
     return () => {
         log(`observeChannels(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
     };
 };
 
+function hasMention(model, userId) {
+    var _a, _b;
+    const channelMention = (_a = model === null || model === void 0 ? void 0 : model.mentionees) === null || _a === void 0 ? void 0 : _a.find(x => x.type === 'channel');
+    if (channelMention) {
+        return true;
+    }
+    const userMention = (_b = model === null || model === void 0 ? void 0 : model.mentionees) === null || _b === void 0 ? void 0 : _b.find(x => x.type === 'user');
+    if (userMention) {
+        return userMention.userIds.includes(userId);
+    }
+    return false;
+}
+function isCollectionOutdated(collection, newItem, action) {
+    const key = identifyModelKey(newItem);
+    // @ts-ignore
+    const item = collection.find(x => x[key] === newItem[key]);
+    if (item) {
+        return hasUpdates(item, newItem);
+    }
+    return action === 'onCreate';
+}
+function merge(collection1, collection2) {
+    const temp = [...collection1, ...collection2];
+    if (temp.length === 0) {
+        return [];
+    }
+    const key = identifyModelKey(temp[0]);
+    const map = new Map();
+    // @ts-ignore
+    temp.forEach(x => map.set(x[key], x));
+    return Array.from(map.values());
+}
+
 /**
  * ```js
- * import { liveChannels } from '@amityco/ts-sdk'
- *
- * let channels = []
- * const unsub = liveChannels({
- *   displayName: Amity.Channel['displayName'],
- * }, response => merge(channels, response.data))
+ * import { onMessageCreated } from '@amityco/ts-sdk'
+ * const dispose = onMessageCreated(message => {
+ *   // ...
+ * })
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Channel}s
+ * Fired when an {@link Amity.Message} has been created
  *
- * @param params for querying channels
- * @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 channels
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Channel Live Collection
+ * @category Message Events
  */
-const liveChannels = (params, callback, config) => {
-    const { log, cache, userId } = getActiveClient();
-    if (!cache) {
-        console.log(ENABLE_CACHE_MESSAGE);
-    }
-    const timestamp = Date.now();
-    log(`liveChannels(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 = ['channel', 'collection', {}];
-    const responder = (data) => {
-        var _a, _b;
-        let channels = (_a = data.data
-            .map(channelId => pullFromCache(['channel', 'get', channelId]))
-            .filter(Boolean)
-            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
-        channels = filterByPropEquality(channels, 'isDeleted', params.isDeleted);
-        channels = filterByPropEquality(channels, 'displayName', params.displayName);
-        if (params.types) {
-            channels = channels.filter(c => { var _a; return (_a = params.types) === null || _a === void 0 ? void 0 : _a.includes(c.type); });
-        }
-        if (params.tags) {
-            channels = channels.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.excludeTags) {
-            channels = channels.filter(c => { var _a; return !((_a = c.tags) === null || _a === void 0 ? void 0 : _a.some(t => { var _a; return (_a = params.excludeTags) === null || _a === void 0 ? void 0 : _a.includes(t); })); });
-        }
-        // userId is required to be able to filter channel by current active user
-        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);
-        }
-        callback({
-            onNextPage: onFetch,
-            data: channels,
-            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
-            loading: data.loading,
-            error: data.error,
-        });
-    };
-    const realtimeRouter = (channel, action) => {
-        var _a;
-        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (!collection)
-            return;
-        if (action === 'onCreate') {
-            collection.data = [...new Set([channel.channelId, ...collection.data])];
-            /*
-             * if the filter isDeleted is set, only collection item must be updated and not
-             * the collection
-             */
-        }
-        else if (action === 'onDelete' && !params.isDeleted) {
-            collection.data = collection.data.filter(c => c !== channel.channelId);
-        }
-        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 channels = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
-        if (channels.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
-            return;
-        const query = createQuery(queryChannels, 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: channels,
-            };
-            if (result) {
-                data.data = [...new Set([...channels, ...result.map(getResolver('channel'))])];
+const onMessageCreated = (callback) => {
+    const client = getActiveClient();
+    const filter = (rawPayload) => {
+        const payload = prepareMessagePayload(rawPayload);
+        const message = payload.messages[0];
+        const cached = pullFromCache(['channel', 'get', message.channelId]);
+        if (cached && cached.data.defaultSubChannelId === message.subChannelId) {
+            let update;
+            // @ts-ignore
+            if (cached.data.localReading) {
+                update = Object.assign(Object.assign({}, cached.data), { localReadToSegment: message.channelSegment, localLastMentionSegment: hasMention(message, client.userId)
+                        ? message.channelSegment
+                        : cached.data.localLastMentionSegment, messageCount: message.channelSegment, lastActivity: message.createdAt, updatedAt: message.createdAt });
             }
-            pushToCache(cacheKey, data);
-            responder(data);
-        }, queryOptions(policy));
+            else {
+                update = Object.assign(Object.assign({}, cached.data), { defaultSubChannelHasUnreadMention: hasMention(message, client.userId) || cached.data.defaultSubChannelHasUnreadMention, defaultSubChannelUnreadCount: message.channelSegment - cached.data.localReadToSegment, lastActivity: message.createdAt, messageCount: message.channelSegment, updatedAt: message.createdAt });
+            }
+            pushToCache(['channel', 'get', message.channelId], update);
+            client.emitter.emit('local.channel.updated', { channels: [update] });
+        }
+        ingestInCache(payload);
+        callback(message);
     };
-    disposers.push(onChannelCreated(channel => realtimeRouter(channel, 'onCreate')), onChannelDeleted(channel => realtimeRouter(channel, 'onDelete')), onChannelUpdated(channel => realtimeRouter(channel, 'onUpdate')));
-    onFetch();
+    const disposers = [
+        createEventSubscriber(client, 'message/onMessageCreated', 'message.created', filter),
+        createEventSubscriber(client, 'local.message.created', 'local.message.created', payload => callback(payload.messages[0])),
+    ];
     return () => {
-        log(`liveChannels(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
     };
 };
 
 /**
  * ```js
- * import { liveChannelMembers } from '@amityco/ts-sdk'
+ * import { onMessageUpdated } from '@amityco/ts-sdk'
+ * const dispose = onMessageUpdated(message => {
+ *   // ...
+ * })
+ * ```
  *
- * let channelMembers = []
+ * Fired when an {@link Amity.Message} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageUpdated = (callback) => {
+    const client = getActiveClient();
+    const filter = (rawPayload) => {
+        const payload = prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'message/onMessageUpdated', 'message.updated', filter),
+        createEventSubscriber(client, 'local.message.updated', 'local.message.updated', payload => callback(payload.messages[0])),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { onMessageDeleted } from '@amityco/ts-sdk'
+ * const dispose = onMessageDeleted(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} was deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageDeleted = (callback) => {
+    const client = getActiveClient();
+    const filter = (rawPayload) => {
+        const payload = prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'message/onMessageDeleted', 'message.deleted', filter),
+        createEventSubscriber(client, 'local.message.deleted', 'local.message.deleted', payload => callback(payload.messages[0])),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { onMessageFlagged } from '@amityco/ts-sdk'
+ * const dispose = onMessageFlagged(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Message} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageFlagged = (callback) => {
+    const client = getActiveClient();
+    const filter = (rawPayload) => {
+        const payload = prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'onMessageFlagged', 'message.flagged', filter);
+};
+
+/**
+ * ```js
+ * import { onMessageUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onMessageUnflagged(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Message}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageUnflagged = (callback) => {
+    const client = getActiveClient();
+    const filter = (rawPayload) => {
+        const payload = prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'onMessageUnflagged', 'message.unflagged', filter);
+};
+
+/**
+ * ```js
+ * import { onMessageFlagCleared } from '@amityco/ts-sdk'
+ * const dispose = onMessageFlagCleared(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when flags have been cleared for a {@link Amity.Message}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageFlagCleared = (callback) => {
+    const client = getActiveClient();
+    const filter = (rawPayload) => {
+        const payload = prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'onMessageFlagCleared', 'message.flagCleared', filter);
+};
+
+/**
+ * ```js
+ * import { onMessageReactionAdded } from '@amityco/ts-sdk';
+ *
+ * const unsubscribe = onMessageReactionAdded(message => {
+ *   // ...
+ * });
+ * ```
+ *
+ * Fired when a {@link Amity.Message} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onMessageReactionAdded = (callback) => {
+    const client = getActiveClient();
+    const filter = (rawPayload) => {
+        const payload = prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'onMessageReactionAdded', 'message.reactionAdded', filter);
+};
+
+/**
+ * ```js
+ * import { onMessageReactionRemoved } from '@amityco/ts-sdk';
+ *
+ * const unsubscribe = onMessageReactionRemoved(message => {
+ *   // ...
+ * });
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Message}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onMessageReactionRemoved = (callback) => {
+    const client = getActiveClient();
+    const filter = (rawPayload) => {
+        const payload = prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'onMessageReactionRemoved', 'message.reactionRemoved', filter);
+};
+
+/**
+ * ```js
+ * import { liveChannel } from '@amityco/ts-sdk';
+ *
+ * let channel;
+ *
+ * const unsubscribe = liveChannel(channelId, response => {
+ *   channel = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Channel}
+ *
+ * @param channelId the ID of the channel 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 channel
+ *
+ * @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());
+    };
+};
+
+/**
+ * ```js
+ * import { liveChannels } from '@amityco/ts-sdk'
+ *
+ * let channels = []
+ * const unsub = liveChannels({
+ *   displayName: Amity.Channel['displayName'],
+ * }, response => merge(channels, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Channel}s
+ *
+ * @param params for querying channels
+ * @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 channels
+ *
+ * @category Channel Live Collection
+ */
+const liveChannels = (params, callback, config) => {
+    const { log, cache, userId } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveChannels(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 = ['channel', 'collection', {}];
+    const responder = (data) => {
+        var _a, _b;
+        let channels = (_a = data.data
+            .map(channelId => pullFromCache(['channel', 'get', channelId]))
+            .filter(Boolean)
+            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+        channels = filterByPropEquality(channels, 'isDeleted', params.isDeleted);
+        channels = filterByPropEquality(channels, 'displayName', params.displayName);
+        if (params.types) {
+            channels = channels.filter(c => { var _a; return (_a = params.types) === null || _a === void 0 ? void 0 : _a.includes(c.type); });
+        }
+        if (params.tags) {
+            channels = channels.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.excludeTags) {
+            channels = channels.filter(c => { var _a; return !((_a = c.tags) === null || _a === void 0 ? void 0 : _a.some(t => { var _a; return (_a = params.excludeTags) === null || _a === void 0 ? void 0 : _a.includes(t); })); });
+        }
+        // userId is required to be able to filter channel by current active user
+        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);
+        }
+        callback({
+            onNextPage: onFetch,
+            data: channels,
+            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (action) => (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])];
+        }
+        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 channels = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        if (channels.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
+            return;
+        const query = createQuery(queryChannels, 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: channels,
+            };
+            if (result) {
+                data.data = [...new Set([...channels, ...result.map(getResolver('channel'))])];
+            }
+            pushToCache(cacheKey, data);
+            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));
+    onFetch();
+    return () => {
+        log(`liveChannels(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { liveChannelMembers } from '@amityco/ts-sdk'
+ *
+ * let channelMembers = []
  * const unsub = liveChannelMembers({
  *   channelId: Amity.Channel['channelId'],
  * }, response => merge(channelMembers, response.data))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.ChannelUser}s
+ * Observe all mutations on a list of {@link Amity.ChannelUser}s
+ *
+ * @param params for querying channel 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 channel users
+ *
+ * @category Channel Live Collection
+ */
+const liveChannelMembers = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveChannelMembers(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 = ['channelUsers', 'collection', { channelId: params.channelId }];
+    const responder = (data) => {
+        var _a, _b;
+        let channelMembers = (_a = data.data
+            .map(id => pullFromCache(['channelUsers', 'get', id]))
+            .filter(Boolean)
+            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+        channelMembers = filterByPropEquality(channelMembers, 'roles', params.roles);
+        if (params.memberships) {
+            /*
+             * even though membership includes muted as a possible value
+             * when querying the server.
+             * Muted is specified under seperarte property namely isMuted
+             * Hence why I've seperately checked for it's equality
+             */
+            channelMembers = channelMembers.filter(member => {
+                // @ts-ignore
+                if (params.memberships.includes('muted') && member.isMuted) {
+                    return true;
+                }
+                // @ts-ignore
+                return params.memberships.includes(member.membership);
+            });
+        }
+        if (params.search) {
+            const containsMatcher = new RegExp(params.search);
+            channelMembers = channelMembers.filter(m => m.userId.match(containsMatcher));
+        }
+        // sort, 'lastCreated' is the default sort order
+        const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+        channelMembers = channelMembers.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+        callback({
+            onNextPage: onFetch,
+            data: channelMembers,
+            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (action) => (channel, channelMember) => {
+        var _a;
+        if (params.channelId !== channelMember.channelId) {
+            return;
+        }
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const channelMemberCacheId = getResolver('channelUsers')({
+            channelId: params.channelId,
+            userId: channelMember.userId,
+        });
+        if (channelMember.membership === 'none') {
+            collection.data = collection.data.filter(m => m !== channelMemberCacheId);
+        }
+        else if (!collection.data.includes(channelMemberCacheId)) {
+            collection.data = [channelMemberCacheId, ...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 channelMembers = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        if (channelMembers.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
+            return;
+        const query = createQuery(queryChannelMembers, 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: channelMembers,
+            };
+            if (result) {
+                data.data = [...new Set([...channelMembers, ...result.map(getResolver('channelUsers'))])];
+            }
+            pushToCache(cacheKey, data);
+            responder(data);
+        }, queryOptions(policy));
+    };
+    disposers.push(onChannelJoined(realtimeRouter()), onChannelLeft(realtimeRouter()), onChannelMemberAdded(realtimeRouter()), onChannelMemberRemoved(realtimeRouter()), onChannelMemberBanned(realtimeRouter()), onChannelMemberUnbanned(realtimeRouter()));
+    onFetch();
+    return () => {
+        log(`liveChannelMembers(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+function convertFromRaw(_a) {
+    var { channelId, channelPublicId, channelType, childCount, creatorId, creatorPublicId, lastMessageId, lastMessageTimestamp, messageFeedId, name } = _a, rest = __rest(_a, ["channelId", "channelPublicId", "channelType", "childCount", "creatorId", "creatorPublicId", "lastMessageId", "lastMessageTimestamp", "messageFeedId", "name"]);
+    return Object.assign(Object.assign({}, rest), { channelId: channelPublicId, creatorId: creatorPublicId, displayName: name, lastActivity: lastMessageTimestamp, latestMessageId: lastMessageId, messageCount: childCount, subChannelId: messageFeedId });
+}
+const prepareSubChannelPayload = (payload) => {
+    return Object.assign(Object.assign({}, payload), { messageFeeds: payload.messageFeeds.map(convertFromRaw) });
+};
+function convertQueryParams(_a) {
+    var { excludeDefaultSubChannel } = _a, rest = __rest(_a, ["excludeDefaultSubChannel"]);
+    const out = Object.assign({}, rest);
+    if (excludeDefaultSubChannel !== undefined) {
+        out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
+    }
+    return out;
+}
+
+/**
+ * ```js
+ * import { querySubChannels } from '@amityco/ts-sdk'
+ * const subChannels = await querySubChannels({ channelId: 'channelId' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.SubChannel} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.SubChannel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+const querySubChannels = async (query) => {
+    const client = getActiveClient();
+    client.log('channel/querySubChannels', query);
+    const _a = convertQueryParams(query), { page = { limit: 10 }, channelId } = _a, params = __rest(_a, ["page", "channelId"]);
+    const response = await client.http.get(`/api/v5/message-feeds/channel/${channelId}`, {
+        params: Object.assign(Object.assign({}, params), { options: {
+                token: toToken(page, 'skiplimit'),
+            } }),
+    });
+    const _b = response.data, { paging } = _b, payload = __rest(_b, ["paging"]);
+    const data = prepareSubChannelPayload(payload);
+    const subChannels = data.messageFeeds;
+    const cachedAt = client.cache && Date.now();
+    if (client.cache) {
+        ingestInCache(data, { cachedAt });
+        const cacheKey = [
+            'subChannel',
+            'query',
+            Object.assign(Object.assign({ channelId }, params), { options: Object.assign({}, page) }),
+        ];
+        pushToCache(cacheKey, { subChannels: subChannels.map(getResolver('subChannel')), paging });
+    }
+    fireEvent('local.message-feed.fetched', data);
+    const nextPage = toPage(paging.next);
+    const prevPage = toPage(paging.previous);
+    return { data: subChannels, cachedAt, prevPage, nextPage };
+};
+/**
+ * ```js
+ * import { querySubChannels } from '@amityco/ts-sdk'
+ * const subChannels = querySubChannels.locally({ channelId: 'channelId' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.SubChannel} objects from cache
+ *
+ * @param query The query parameters
+ * @returns sub channels
+ *
+ * @category Channel API
+ */
+querySubChannels.locally = (query) => {
+    var _a, _b, _c;
+    const client = getActiveClient();
+    client.log('channel/querySubChannels.locally', query);
+    // @ts-ignore
+    const _d = (_a = convertQueryParams(query)) !== null && _a !== void 0 ? _a : {}, { page = { limit: 10 }, channelId } = _d, params = __rest(_d, ["page", "channelId"]);
+    const cacheKey = [
+        'subChannel',
+        'query',
+        Object.assign(Object.assign({ channelId }, params), { options: Object.assign({}, page) }),
+    ];
+    const { data, cachedAt } = (_b = pullFromCache(cacheKey)) !== null && _b !== void 0 ? _b : {};
+    if (!(data === null || data === void 0 ? void 0 : data.subChannels.length))
+        return;
+    const subChannels = data.subChannels
+        .map(ck => pullFromCache(['subChannel', 'get', ck]))
+        .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);
+    return subChannels.length === ((_c = data === null || data === void 0 ? void 0 : data.subChannels) === null || _c === void 0 ? void 0 : _c.length)
+        ? { data: subChannels, cachedAt, prevPage, nextPage }
+        : undefined;
+};
+
+/**
+ * ```js
+ * import { getSubChannels } from '@amityco/ts-sdk'
+ * const subChannels = await getSubChannels(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.SubChannel} objects
+ *
+ * @param subChannelIds the IDs of the {@link Amity.SubChannel} to fetch
+ * @returns the associated collection of {@link Amity.SubChannel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+const getSubChannels = async (subChannelIds) => {
+    const client = getActiveClient();
+    client.log('channel/getSubChannels', subChannelIds);
+    const response = await client.http.get('/api/v5/message-feeds/list', {
+        params: { messageFeedIds: subChannelIds.map(encodeURIComponent) },
+    });
+    const data = prepareSubChannelPayload(response.data);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    fireEvent('local.message-feed.fetched', data);
+    return {
+        data: data.messageFeeds,
+        cachedAt,
+    };
+};
+/**
+ * ```js
+ * import { getSubChannels } from '@amityco/ts-sdk'
+ * const subChannels = getSubChannels.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.SubChannel} objects from cache
+ *
+ * @param subChannelIds the IDs of the {@link Amity.SubChannel} to fetch
+ * @returns the associated collection of {@link Amity.SubChannel} objects
+ *
+ * @category Channel API
+ */
+getSubChannels.locally = (subChannelIds) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('channel/getSubChannels.locally', subChannelIds);
+    if (!client.cache)
+        return;
+    const cached = subChannelIds
+        .map(channelId => pullFromCache(['subChannel', 'get', channelId]))
+        .filter(Boolean);
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) < subChannelIds.length)
+        return;
+    const subChannels = cached.map(({ data }) => data);
+    const oldest = (_a = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _a === void 0 ? void 0 : _a[0];
+    return {
+        data: subChannels,
+        cachedAt: oldest.cachedAt,
+    };
+};
+
+/**
+ * ```js
+ * import { getSubChannel } from '@amityco/ts-sdk'
+ * const subChannel = await getSubChannel('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.SubChannel} object
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ * @async
+ */
+const getSubChannel = async (subChannelId) => {
+    const client = getActiveClient();
+    client.log('channel/getSubChannel', subChannelId);
+    isInTombstone('subChannel', subChannelId);
+    try {
+        const response = await client.http.get(`/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`);
+        const data = prepareSubChannelPayload(response.data);
+        const cachedAt = client.cache && Date.now();
+        if (client.cache)
+            ingestInCache(data, { cachedAt });
+        fireEvent('local.message-feed.fetched', data);
+        return {
+            data: data.messageFeeds[0],
+            cachedAt,
+        };
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('subChannel', subChannelId);
+        }
+        throw error;
+    }
+};
+/**
+ * ```js
+ * import { getSubChannel } from '@amityco/ts-sdk'
+ * const subChannel = getSubChannel.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.SubChannel} object from cache
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ */
+getSubChannel.locally = (subChannelId) => {
+    const client = getActiveClient();
+    client.log('channel/getSubChannel.locally', subChannelId);
+    if (!client.cache)
+        return;
+    const cached = pullFromCache(['subChannel', 'get', subChannelId]);
+    if (!cached)
+        return;
+    return {
+        data: cached.data,
+        cachedAt: cached.cachedAt,
+    };
+};
+
+/**
+ * ```js
+ * import { createSubChannel } from '@amityco/ts-sdk'
+ * const created = await createSubChannel({ channelId: 'foobar', name: 'foobar' })
+ * ```
+ *
+ * Creates an {@link Amity.SubChannel}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.SubChannel}
+ * @returns The newly created {@link Amity.SubChannel}
+ *
+ * @category Channel API
+ * @async
+ */
+const createSubChannel = async (bundle) => {
+    const client = getActiveClient();
+    client.log('user/createSubChannel', bundle);
+    const response = await client.http.post('/api/v5/message-feeds', {
+        channelId: bundle.channelId,
+        name: bundle.displayName,
+    });
+    const data = prepareSubChannelPayload(response.data);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    fireEvent('message-feed.created', response.data);
+    return {
+        data: data.messageFeeds[0],
+        cachedAt,
+    };
+};
+
+/**
+ * ```js
+ * import { updateSubChannel } from '@amityco/ts-sdk'
+ * const updated = await updateSubChannel(subChannelId, { name: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.SubChannel}
+ *
+ * @param subChannelId The ID of the {@link Amity.SubChannel} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ * @async
+ */
+const updateSubChannel = async (subChannelId, patch) => {
+    const client = getActiveClient();
+    client.log('channel/updateSubChannel', subChannelId, patch);
+    const response = await client.http.put(`/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`, { name: patch.displayName });
+    const data = prepareSubChannelPayload(response.data);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    fireEvent('message-feed.updated', response.data);
+    return {
+        data: data.messageFeeds[0],
+        cachedAt,
+    };
+};
+
+/**
+ * ```js
+ * import { deleteSubChannel } from '@amityco/ts-sdk'
+ * const success = await deleteSubChannel('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.SubChannel}
  *
- * @param params for querying channel 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 channel users
+ * @param subChannelId The {@link Amity.SubChannel} ID to delete
+ * @return A success boolean if the {@link Amity.SubChannel} was deleted
  *
- * @category Channel Live Collection
+ * @category Channel API
+ * @async
  */
-const liveChannelMembers = (params, callback, config) => {
-    const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log(ENABLE_CACHE_MESSAGE);
+const deleteSubChannel = async (subChannelId, permanent = false) => {
+    const client = getActiveClient();
+    client.log('channel/deleteSubChannel', subChannelId);
+    const subChannel = await getSubChannel(subChannelId);
+    await client.http.delete(`/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`, { params: { permanent } });
+    const deleted = Object.assign(Object.assign({}, subChannel.data), { isDeleted: true, updatedAt: getFutureDate(subChannel.data.updatedAt) });
+    if (permanent) {
+        setTimeout(() => {
+            pushToTombstone('subChannel', subChannelId);
+        }, 0);
     }
-    const timestamp = Date.now();
-    log(`liveChannelMembers(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 = ['channelUsers', 'collection', { channelId: params.channelId }];
-    const responder = (data) => {
-        var _a, _b;
-        let channelMembers = (_a = data.data
-            .map(id => pullFromCache(['channelUsers', 'get', id]))
-            .filter(Boolean)
-            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
-        channelMembers = filterByPropEquality(channelMembers, 'roles', params.roles);
-        if (params.memberships) {
-            /*
-             * even though membership includes muted as a possible value
-             * when querying the server.
-             * Muted is specified under seperarte property namely isMuted
-             * Hence why I've seperately checked for it's equality
-             */
-            if (params.memberships.some(m => ['member', 'banned'].includes(m))) {
-                channelMembers = filterByPropInclusion(channelMembers, 'membership', params.memberships);
-            }
-            if (params.memberships.includes('muted')) {
-                channelMembers = filterByPropEquality(channelMembers, 'isMuted', true);
-            }
-        }
-        if (params.search) {
-            const containsMatcher = new RegExp(params.search);
-            channelMembers = channelMembers.filter(m => m.userId.match(containsMatcher));
-        }
-        // sort, 'lastCreated' is the default sort order
-        const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
-        channelMembers = channelMembers.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
-        callback({
-            onNextPage: onFetch,
-            data: channelMembers,
-            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
-            loading: data.loading,
-            error: data.error,
-        });
-    };
-    const realtimeRouter = (channelMember, action) => {
-        var _a;
-        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (!collection)
-            return;
-        const channelMemberCacheId = getResolver('channelUsers')({
-            channelId: params.channelId,
-            userId: channelMember.userId,
-        });
-        if (action === 'onMemberAdded') {
-            collection.data = [...new Set([channelMemberCacheId, ...collection.data])];
-        }
-        if (action === 'onMemberRemoved') {
-            collection.data = collection.data.filter(m => m !== channelMemberCacheId);
-        }
-        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 channelMembers = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
-        if (channelMembers.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
-            return;
-        const query = createQuery(queryChannelMembers, 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: channelMembers,
-            };
-            if (result) {
-                data.data = [...new Set([...channelMembers, ...result.map(getResolver('channelUsers'))])];
-            }
-            pushToCache(cacheKey, data);
-            responder(data);
-        }, queryOptions(policy));
-    };
-    disposers.push(onChannelMemberAdded((_, member) => realtimeRouter(member, 'onMemberAdded')), onChannelMemberRemoved((_, member) => realtimeRouter(member, 'onMemberRemoved')), onChannelMemberBanned((_, member) => realtimeRouter(member, 'onChannelMemberBanned')), onChannelMemberUnbanned((_, member) => realtimeRouter(member, 'onChannelMemberUnbanned')));
-    onFetch();
-    return () => {
-        log(`liveChannelMembers(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
+    else {
+        upsertInCache(['subChannel', 'get', subChannelId], deleted);
+    }
+    fireEvent('local.message-feed.deleted', { messageFeeds: [deleted] });
+    return deleted;
 };
 
 /**
  * ```js
- * import { onMessageCreated } from '@amityco/ts-sdk'
- * const dispose = onMessageCreated(message => {
+ * import { onChannelSubCreated } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelCreated(subChannel => {
  *   // ...
  * })
  * ```
  *
- * Fired when an {@link Amity.Message} has been created
+ * Fired when any {@link Amity.SubChannel} have been created
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Message Events
+ * @category Channel Events
  */
-const onMessageCreated = (callback) => {
+const onSubChannelCreated = (callback) => {
     const client = getActiveClient();
-    const filter = (payload) => {
+    const filter = (rawPayload) => {
+        const payload = prepareSubChannelPayload(rawPayload);
         ingestInCache(payload);
-        callback(payload.messages[0]);
+        callback(payload.messageFeeds[0]);
     };
-    return createEventSubscriber(client, 'message/onMessageCreated', 'v3.message.didCreate', filter);
+    return createEventSubscriber(client, 'onSubChannelCreated', 'message-feed.created', filter);
 };
 
 /**
  * ```js
- * import { onMessageUpdated } from '@amityco/ts-sdk'
- * const dispose = onMessageUpdated(message => {
+ * import { onSubChannelUpdated } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelUpdated(subChannel => {
  *   // ...
  * })
  * ```
  *
- * Fired when an {@link Amity.Message} has been updated
+ * Fired when any {@link Amity.SubChannel} have been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Message Events
+ * @category Channel Events
  */
-const onMessageUpdated = (callback) => {
+const onSubChannelUpdated = (callback) => {
     const client = getActiveClient();
-    const filter = (payload) => {
+    const filter = (rawPayload) => {
+        const payload = prepareSubChannelPayload(rawPayload);
         ingestInCache(payload);
-        const message = payload.messages[0];
-        // if payload does not have myReactions
-        if (!(message === null || message === void 0 ? void 0 : message.myReactions)) {
-            prepareMessagePayloadForCache(message);
-        }
-        callback(message);
+        callback(payload.messageFeeds[0]);
     };
-    return createEventSubscriber(client, 'message/onMessageUpdated', 'v3.message.didUpdate', filter);
+    return createEventSubscriber(client, 'onSubChannelUpdated', 'message-feed.updated', filter);
 };
 
 /**
  * ```js
- * import { onMessageDeleted } from '@amityco/ts-sdk'
- * const dispose = onMessageDeleted(message => {
+ * import { onSubChannelDeleted } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelDeleted(subChannel => {
  *   // ...
  * })
  * ```
  *
- * Fired when an {@link Amity.Message} was deleted
+ * Fired when any {@link Amity.SubChannel} have been deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Message Events
+ * @category Channel Events
  */
-const onMessageDeleted = (callback) => {
+const onSubChannelDeleted = (callback) => {
     const client = getActiveClient();
-    const filter = (payload) => {
+    const filter = (rawPayload) => {
+        const payload = prepareSubChannelPayload(rawPayload);
         ingestInCache(payload);
-        callback(payload.messages[0]);
+        callback(payload.messageFeeds[0]);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'onSubChannelDeleted', 'message-feed.deleted', filter),
+        createEventSubscriber(client, 'local.message-feed.deleted', 'local.message-feed.deleted', payload => callback(payload.messageFeeds[0])),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+/** @hidden */
+const onSubChannelFetched = (callback) => {
+    return createEventSubscriber(getActiveClient(), 'onSubChannelFetched', 'local.message-feed.fetched', payload => callback(payload.messageFeeds[0]));
+};
+
+/**
+ * ```js
+ * import { liveSubChannel } from '@amityco/ts-sdk';
+ *
+ * let subChannel;
+ *
+ * const unsubscribe = liveSubChannel(subChannelId, response => {
+ *   subChannel = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.SubChannel}
+ *
+ * @param subChannelId 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 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());
+    };
+};
+
+/**
+ * ```js
+ * import { liveSubChannels } from '@amityco/ts-sdk';
+ *
+ * let subChannels = [];
+ *
+ * const unsubscribe = liveSubChannels({ channelId }, response => {
+ *   merge(subChannels, response.data);
+ * });
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.SubChannel}s
+ *
+ * @param params for querying sub channels
+ * @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 channels
+ *
+ * @category SubChannel Live Collection
+ */
+const liveSubChannels = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    const timestamp = Date.now();
+    log(`liveSubChannels(tmpid: ${timestamp}) > listen`);
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = params, queryParams = __rest(params, ["limit"]);
+    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
+    let snapshot;
+    const disposers = [];
+    const responder = (data) => {
+        var _a;
+        let subChannels = data.data;
+        if (params.isDeleted !== undefined) {
+            subChannels = filterByPropEquality(subChannels, 'isDeleted', params.isDeleted);
+        }
+        subChannels.sort(sortByLastActivity);
+        callback({
+            onNextPage: onFetch,
+            data: subChannels,
+            hasNextPage: !!((_a = data.params) === null || _a === void 0 ? void 0 : _a.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (action) => (subChannel) => {
+        if (params.channelId !== subChannel.channelId ||
+            !snapshot ||
+            !isCollectionOutdated(snapshot.data, subChannel, action)) {
+            return;
+        }
+        if (action === 'onCreate') {
+            snapshot.data = [subChannel, ...snapshot.data];
+        }
+        else {
+            snapshot.data = snapshot.data.map(x => x.subChannelId === subChannel.subChannelId ? subChannel : x);
+        }
+        responder(snapshot);
+    };
+    const onFetch = () => {
+        var _a;
+        const subChannels = snapshot ? snapshot.data : [];
+        if (subChannels.length > 0 && !(snapshot === null || snapshot === void 0 ? void 0 : snapshot.params.page)) {
+            return;
+        }
+        const query = createQuery(querySubChannels, Object.assign(Object.assign({}, queryParams), { page: (_a = snapshot === null || snapshot === void 0 ? void 0 : snapshot.params.page) !== null && _a !== void 0 ? _a : { limit } }));
+        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
+            snapshot = {
+                loading,
+                error,
+                params: { page },
+                data: result ? merge(subChannels, result) : subChannels,
+            };
+            responder(snapshot);
+        }, queryOptions(policy));
+    };
+    disposers.push(onSubChannelCreated(realtimeRouter('onCreate')), onSubChannelDeleted(realtimeRouter('onDelete')), onSubChannelFetched(realtimeRouter('onFetch')), onSubChannelUpdated(realtimeRouter('onUpdate')));
+    onFetch();
+    return () => {
+        log(`liveSubChannels(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
     };
-    return createEventSubscriber(client, 'message/onMessageDeleted', 'v3.message.didDelete', filter);
 };
 
 /**
@@ -25582,46 +26748,50 @@ const onMessageFetched = (callback) => {
         ingestInCache(payload);
         callback(payload.messages[0]);
     };
-    return createEventSubscriber(client, 'message/onMessageFetched', 'v3.message.didFetch', filter);
+    return createEventSubscriber(client, 'message/onMessageFetched', 'local.message.fetched', filter);
 };
 
 /**
  * ```js
- * import { liveMessage } from '@amityco/ts-sdk'
+ * import { liveMessage } from '@amityco/ts-sdk';
  *
- * let messages = []
- * const unsub = liveMessage(messageId, response => merge(messages, response.data))
+ * let message;
+ *
+ * const unsubscribe = liveMessage(messageId, response => {
+ *   message = response.data;
+ * });
  * ```
  *
  * Observe all mutation on a given {@link Amity.Message}
  *
  * @param messageId 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 messages
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the message
  *
  * @category Message Live Object
  */
 const liveMessage = (messageId, callback) => {
     const { log, cache } = getActiveClient();
-    let message;
-    let isUnsyncedObject = false;
+    const timestamp = Date.now();
+    log(`liveMessage(tmpid: ${timestamp}) > listen`);
     if (!cache) {
         console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
     }
-    const timestamp = Date.now();
-    log(`liveMessage(tmpid: ${timestamp}) > listen`);
+    let message;
+    let isUnsyncedObject = false;
     const disposers = [];
     const dispatcher = (data) => {
-        var _a;
-        // we check updatedAt to see if the current snapshot is new so
-        // we won't send old data back, only fresh new data
-        if (message && ((_a = data.data) === null || _a === void 0 ? void 0 : _a.updatedAt) === (message === null || message === void 0 ? void 0 : message.updatedAt) && data.origin !== 'server')
-            return;
-        callback(data);
         message = data.data;
+        callback(data);
     };
-    const realtimeRouter = (message, action) => {
-        dispatcher({ loading: false, data: message, origin: 'event' });
+    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);
@@ -25640,12 +26810,11 @@ const liveMessage = (messageId, callback) => {
                 dispatcher({ loading, data, origin, error });
             }
             if (error) {
-                // Terminate observe functionality on error
                 disposers.forEach(fn => fn());
             }
         });
     };
-    disposers.push(onMessageFetched(message => realtimeRouter(message)), onMessageUpdated(message => realtimeRouter(message)), onMessageDeleted(message => realtimeRouter(message)));
+    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`);
@@ -25655,17 +26824,18 @@ const liveMessage = (messageId, callback) => {
 
 /**
  * ```js
- * import { liveMessages } from '@amityco/ts-sdk'
+ * import { liveMessages } from '@amityco/ts-sdk';
  *
- * let messages = []
- * const unsub = liveMessages({
- *   channelId: Amity.Channel['channelId'];
- * }, response => merge(messages, response.data))
+ * let messages = [];
+ *
+ * const unsubscribe = liveMessages({
+ *   subChannelId: Amity.SubChannel['subChannelId'];
+ * }, response => merge(messages, response.data));
  * ```
  *
  * Observe all mutations on a list of {@link Amity.Message} for a given target object
  *
- * @param params for querying memssages from a channel
+ * @param params for querying messages from a sub channel
  * @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
  *
@@ -25682,7 +26852,7 @@ const liveMessages = (params, callback, config) => {
     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 = ['message', 'collection', { channelId: params.channelId }];
+    const cacheKey = ['message', 'collection', { subChannelId: params.subChannelId }];
     const responder = (data) => {
         var _a, _b;
         let messages = (_a = data.data
@@ -25702,10 +26872,10 @@ const liveMessages = (params, callback, config) => {
             error: data.error,
         });
     };
-    const realtimeRouter = (message, action) => {
+    const realtimeRouter = (action) => (message) => {
         var _a;
         const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (params.channelId !== message.channelId || !collection)
+        if (params.subChannelId !== message.subChannelId || !collection)
             return;
         if (action === 'onCreate') {
             collection.data = [...new Set([message.messageId, ...collection.data])];
@@ -25737,7 +26907,7 @@ const liveMessages = (params, callback, config) => {
             responder(data);
         }, queryOptions(policy));
     };
-    disposers.push(onMessageFetched(message => realtimeRouter(message, 'onFetch')), onMessageCreated(message => realtimeRouter(message, 'onCreate')), onMessageDeleted(message => realtimeRouter(message, 'onDelete')), onMessageUpdated(message => realtimeRouter(message, 'onUpdate')));
+    disposers.push(onMessageFetched(realtimeRouter('onFetch')), onMessageCreated(realtimeRouter('onCreate')), onMessageUpdated(realtimeRouter('onUpdate')), onMessageDeleted(realtimeRouter('onDelete')), onMessageFlagged(realtimeRouter('onFlagged')), onMessageUnflagged(realtimeRouter('onUnflagged')), onMessageFlagCleared(realtimeRouter('onFlagCleared')), onMessageReactionAdded(realtimeRouter('onReactionAdded')), onMessageReactionRemoved(realtimeRouter('onReactionRemoved')));
     onFetch();
     return () => {
         log(`liveMessages(tmpid: ${timestamp}) > dispose`);
@@ -25750,6 +26920,7 @@ const liveMessages = (params, callback, config) => {
  * import { observeMessage } from '@amityco/ts-sdk'
  *
  * let message = {}
+ *
  * const unsub = observeMessage(messageId, updated => message = updated)
  * ```
  *
@@ -25796,25 +26967,26 @@ const observeMessage = (messageId, callback, policy = 'cache_then_server') => {
  * import { observeMessages } from '@amityco/ts-sdk'
  *
  * let messages = []
- * const unsub = observeMessages(channelId, message => merge(messages, message))
+ *
+ * const unsubscribe = observeMessages(channelId, message => merge(messages, message))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.Channel} object
+ * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.SubChannel} object
  *
- * @param channelId the ID of the channel where to observe the messages
+ * @param subChannelId the ID of the channel where to observe the messages
  * @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
  *
  * @category Message Observer
  */
-const observeMessages = (channelId, callback) => {
+const observeMessages = (subChannelId, callback) => {
     const { log } = getActiveClient();
     const timestamp = Date.now();
     log(`observeMessages(tmpid: ${timestamp}) > listen`);
     const disposers = [];
     const router = (message, action) => {
         var _a, _b, _c;
-        if (((_a = message.data) === null || _a === void 0 ? void 0 : _a.channelId) !== channelId)
+        if (((_a = message.data) === null || _a === void 0 ? void 0 : _a.subChannelId) !== subChannelId)
             return;
         if (callback instanceof Function)
             return callback(message);
@@ -25877,22 +27049,23 @@ function getEventRelatedMember(event, payload) {
 const createCommunityMemberEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        const unpackedPayload = unpackCommunityPayload(payload);
+        const communityPayload = unpackCommunityPayload(payload);
+        const preparedPayload = prepareMembershipPayload(communityPayload, 'communityUsers');
         if (!client.cache) {
             // TODO: here we are missing specific properties here!
-            callback(unpackedPayload.communities[0], getEventRelatedMember(event, unpackedPayload));
+            callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
         }
         else {
-            ingestInCache(unpackedPayload);
+            ingestInCache(preparedPayload);
             const community = pullFromCache([
                 'community',
                 'get',
-                unpackedPayload.communities[0].communityId,
+                preparedPayload.communities[0].communityId,
             ]);
             const member = pullFromCache([
                 'communityUsers',
                 'get',
-                getResolver('communityUsers')(getEventRelatedMember(event, unpackedPayload)),
+                getResolver('communityUsers')(getEventRelatedMember(event, preparedPayload)),
             ]);
             callback(community.data, member.data);
         }
@@ -26931,7 +28104,7 @@ const liveFollowers = (params, callback, config) => {
             error: data.error,
         });
     };
-    const realtimeRouter = (followStatus, action) => {
+    const realtimeRouter = (action) => (followStatus) => {
         var _a;
         const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
         if (params.userId !== followStatus.to || !collection)
@@ -26966,7 +28139,7 @@ const liveFollowers = (params, callback, config) => {
             responder(data);
         }, queryOptions(policy));
     };
-    disposers.push(onFollowerRequested(followStatus => realtimeRouter(followStatus, 'onRequested')), onFollowRequestAccepted(followStatus => realtimeRouter(followStatus, 'onAccepted')), onFollowRequestDeclined(followStatus => realtimeRouter(followStatus, 'onDeclined')), onFollowRequestCanceled(followStatus => realtimeRouter(followStatus, 'onCanceled')), onUserFollowed(followStatus => realtimeRouter(followStatus, 'onFollowed')), onUserUnfollowed(followStatus => realtimeRouter(followStatus, 'onUnfollowed')), onFollowerDeleted(followStatus => realtimeRouter(followStatus, 'onDeleted')));
+    disposers.push(onFollowerRequested(realtimeRouter('onRequested')), onFollowRequestAccepted(realtimeRouter('onAccepted')), onFollowRequestDeclined(realtimeRouter('onDeclined')), onFollowRequestCanceled(realtimeRouter('onCanceled')), onUserFollowed(realtimeRouter('onFollowed')), onUserUnfollowed(realtimeRouter('onUnfollowed')), onFollowerDeleted(realtimeRouter('onDeleted')));
     onFetch();
     return () => {
         log(`liveFollowers(tmpid: ${timestamp}) > dispose`);
@@ -27021,7 +28194,7 @@ const liveFollowings = (params, callback, config) => {
             error: data.error,
         });
     };
-    const realtimeRouter = (followStatus, action) => {
+    const realtimeRouter = (action) => (followStatus) => {
         var _a;
         const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
         if (params.userId !== followStatus.from || !collection)
@@ -27056,7 +28229,7 @@ const liveFollowings = (params, callback, config) => {
             responder(data);
         }, queryOptions(policy));
     };
-    disposers.push(onFollowerRequested(followStatus => realtimeRouter(followStatus, 'onRequested')), onFollowRequestAccepted(followStatus => realtimeRouter(followStatus, 'onAccepted')), onFollowRequestDeclined(followStatus => realtimeRouter(followStatus, 'onDeclined')), onFollowRequestCanceled(followStatus => realtimeRouter(followStatus, 'onCanceled')), onUserFollowed(followStatus => realtimeRouter(followStatus, 'onFollowed')), onUserUnfollowed(followStatus => realtimeRouter(followStatus, 'onUnfollowed')), onFollowerDeleted(followStatus => realtimeRouter(followStatus, 'onDeleted')));
+    disposers.push(onFollowerRequested(realtimeRouter('onRequested')), onFollowRequestAccepted(realtimeRouter('onAccepted')), onFollowRequestDeclined(realtimeRouter('onDeclined')), onFollowRequestCanceled(realtimeRouter('onCanceled')), onUserFollowed(realtimeRouter('onFollowed')), onUserUnfollowed(realtimeRouter('onUnfollowed')), onFollowerDeleted(realtimeRouter('onDeleted')));
     onFetch();
     return () => {
         log(`liveFollowings(tmpid: ${timestamp}) > dispose`);
@@ -27194,6 +28367,9 @@ const livePosts = (params, callback, config) => {
         posts = filterByPropEquality(posts, 'isDeleted', params.isDeleted);
         const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
         posts = posts.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+        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); }); });
+        }
         callback({
             onNextPage: onFetch,
             data: posts,
@@ -27202,17 +28378,32 @@ const livePosts = (params, callback, config) => {
             error: data.error,
         });
     };
-    const realtimeRouter = (post, action) => {
+    const realtimeRouter = (action) => (post) => {
         var _a;
         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 (action === 'onCreate') {
+        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
+         */
+        if (params.feedType === 'reviewing' && action === 'onApproved')
+            collection.data = collection.data.filter(p => p !== post.postId);
         pushToCache(cacheKey, collection);
         responder(collection);
     };
@@ -27237,7 +28428,7 @@ const livePosts = (params, callback, config) => {
             responder(data);
         }, queryOptions(policy));
     };
-    disposers.push(onPostCreated(post => realtimeRouter(post, 'onCreate')), onPostApproved(post => realtimeRouter(post, 'onApproved')), onPostDeclined(post => realtimeRouter(post, 'onDeclined')), onPostDeleted(post => realtimeRouter(post, 'onDelete')), onPostUpdated(post => realtimeRouter(post, 'onUpdate')), onPostFlagged(post => realtimeRouter(post, 'onFlagged')), onPostUnflagged(post => realtimeRouter(post, 'onUnflagged')), onPostReactionAdded(post => realtimeRouter(post, 'onReactionAdded')), onPostReactionRemoved(post => realtimeRouter(post, 'onReactionRemoved')));
+    disposers.push(onPostCreated(realtimeRouter('onCreate')), onPostApproved(realtimeRouter('onApproved')), onPostDeclined(realtimeRouter('onDeclined')), onPostDeleted(realtimeRouter('onDelete')), onPostUpdated(realtimeRouter('onUpdate')), onPostFlagged(realtimeRouter('onFlagged')), onPostUnflagged(realtimeRouter('onUnflagged')), onPostReactionAdded(realtimeRouter('onReactionAdded')), onPostReactionRemoved(realtimeRouter('onReactionRemoved')));
     onFetch();
     return () => {
         log(`livePosts(tmpid: ${timestamp}) > dispose`);
@@ -27379,7 +28570,7 @@ const liveComments = (params, callback, config) => {
             error: data.error,
         });
     };
-    const realtimeRouter = (comment, action) => {
+    const realtimeRouter = (action) => (comment) => {
         var _a;
         const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
         if (params.referenceId !== comment.referenceId ||
@@ -27418,7 +28609,7 @@ const liveComments = (params, callback, config) => {
             responder(data);
         }, queryOptions(policy));
     };
-    disposers.push(onCommentCreated(comment => realtimeRouter(comment, 'onCreate')), onCommentUpdated(comment => realtimeRouter(comment, 'onUpdate')), onCommentDeleted(comment => realtimeRouter(comment, 'onDelete')), onCommentFlagged(comment => realtimeRouter(comment, 'onFlagged')), onCommentUnflagged(comment => realtimeRouter(comment, 'onUnflagged')), onCommentReactionAdded(comment => realtimeRouter(comment, 'onReactionAdded')), onCommentReactionRemoved(comment => realtimeRouter(comment, 'onReactionRemoved')));
+    disposers.push(onCommentCreated(realtimeRouter('onCreate')), onCommentUpdated(realtimeRouter('onUpdate')), onCommentDeleted(realtimeRouter('onDelete')), onCommentFlagged(realtimeRouter('onFlagged')), onCommentUnflagged(realtimeRouter('onUnflagged')), onCommentReactionAdded(realtimeRouter('onReactionAdded')), onCommentReactionRemoved(realtimeRouter('onReactionRemoved')));
     onFetch();
     return () => {
         log(`liveComments(tmpid: ${timestamp}) > dispose`);
@@ -28045,6 +29236,7 @@ exports.createPost = createPost;
 exports.createQuery = createQuery;
 exports.createReport = createReport;
 exports.createStream = createStream;
+exports.createSubChannel = createSubChannel;
 exports.createUserToken = createUserToken;
 exports.createVideo = createVideo;
 exports.declineFollower = declineFollower;
@@ -28058,6 +29250,7 @@ exports.deletePoll = deletePoll;
 exports.deletePost = deletePost;
 exports.deleteReport = deleteReport;
 exports.deleteStream = deleteStream;
+exports.deleteSubChannel = deleteSubChannel;
 exports.disableCache = disableCache;
 exports.disconnectClient = disconnectClient;
 exports.disposeStream = disposeStream;
@@ -28071,6 +29264,7 @@ exports.follow = follow;
 exports.getActiveClient = getActiveClient;
 exports.getCategory = getCategory;
 exports.getChannel = getChannel;
+exports.getChannelTopic = getChannelTopic;
 exports.getChannels = getChannels;
 exports.getComment = getComment;
 exports.getCommentTopic = getCommentTopic;
@@ -28082,6 +29276,7 @@ exports.getFeedSettings = getFeedSettings;
 exports.getFile = getFile;
 exports.getFollowInfo = getFollowInfo;
 exports.getMessage = getMessage;
+exports.getMessageTopic = getMessageTopic;
 exports.getMessages = getMessages;
 exports.getMyFollowersTopic = getMyFollowersTopic;
 exports.getMyFollowingsTopic = getMyFollowingsTopic;
@@ -28092,7 +29287,13 @@ exports.getPostTopic = getPostTopic;
 exports.getPosts = getPosts;
 exports.getRecommendedCommunities = getRecommendedCommunities;
 exports.getRole = getRole;
+exports.getSmartFeedChannelTopic = getSmartFeedChannelTopic;
+exports.getSmartFeedMessageTopic = getSmartFeedMessageTopic;
+exports.getSmartFeedSubChannelTopic = getSmartFeedSubChannelTopic;
 exports.getStream = getStream;
+exports.getSubChannel = getSubChannel;
+exports.getSubChannelTopic = getSubChannelTopic;
+exports.getSubChannels = getSubChannels;
 exports.getTopTrendingCommunities = getTopTrendingCommunities;
 exports.getUser = getUser;
 exports.getUserTopic = getUserTopic;
@@ -28113,6 +29314,7 @@ exports.joinChannel = joinChannel;
 exports.joinCommunity = joinCommunity;
 exports.leaveChannel = leaveChannel;
 exports.leaveCommunity = leaveCommunity;
+exports.liveChannel = liveChannel;
 exports.liveChannelMembers = liveChannelMembers;
 exports.liveChannels = liveChannels;
 exports.liveComments = liveComments;
@@ -28122,6 +29324,8 @@ exports.liveMessage = liveMessage;
 exports.liveMessages = liveMessages;
 exports.livePosts = livePosts;
 exports.liveReactions = liveReactions;
+exports.liveSubChannel = liveSubChannel;
+exports.liveSubChannels = liveSubChannels;
 exports.liveUser = liveUser;
 exports.mergeInCache = mergeInCache;
 exports.observeChannel = observeChannel;
@@ -28147,6 +29351,7 @@ exports.onChannelMemberAdded = onChannelMemberAdded;
 exports.onChannelMemberBanned = onChannelMemberBanned;
 exports.onChannelMemberRemoved = onChannelMemberRemoved;
 exports.onChannelMemberUnbanned = onChannelMemberUnbanned;
+exports.onChannelMuted = onChannelMuted;
 exports.onChannelUpdated = onChannelUpdated;
 exports.onClientBanned = onClientBanned;
 exports.onClientDisconnected = onClientDisconnected;
@@ -28175,7 +29380,11 @@ exports.onFollowerDeleted = onFollowerDeleted;
 exports.onFollowerRequested = onFollowerRequested;
 exports.onMessageCreated = onMessageCreated;
 exports.onMessageDeleted = onMessageDeleted;
-exports.onMessageFetched = onMessageFetched;
+exports.onMessageFlagCleared = onMessageFlagCleared;
+exports.onMessageFlagged = onMessageFlagged;
+exports.onMessageReactionAdded = onMessageReactionAdded;
+exports.onMessageReactionRemoved = onMessageReactionRemoved;
+exports.onMessageUnflagged = onMessageUnflagged;
 exports.onMessageUpdated = onMessageUpdated;
 exports.onPollDeleted = onPollDeleted;
 exports.onPollUpdated = onPollUpdated;
@@ -28195,8 +29404,10 @@ exports.onReactorRemoved = onReactorRemoved;
 exports.onStreamRecorded = onStreamRecorded;
 exports.onStreamStarted = onStreamStarted;
 exports.onStreamStopped = onStreamStopped;
+exports.onSubChannelCreated = onSubChannelCreated;
+exports.onSubChannelDeleted = onSubChannelDeleted;
+exports.onSubChannelUpdated = onSubChannelUpdated;
 exports.onUserDeleted = onUserDeleted;
-exports.onUserFetched = onUserFetched;
 exports.onUserFlagCleared = onUserFlagCleared;
 exports.onUserFlagged = onUserFlagged;
 exports.onUserFollowed = onUserFollowed;
@@ -28221,6 +29432,7 @@ exports.queryPosts = queryPosts;
 exports.queryReactions = queryReactions;
 exports.queryRoles = queryRoles;
 exports.queryStreams = queryStreams;
+exports.querySubChannels = querySubChannels;
 exports.queryUsers = queryUsers;
 exports.removeChannelMembers = removeChannelMembers;
 exports.removeChannelMembersRole = removeChannelMembersRole;
@@ -28235,6 +29447,8 @@ exports.sortByFirstCreated = sortByFirstCreated;
 exports.sortByLastActivity = sortByLastActivity;
 exports.sortByLastCreated = sortByLastCreated;
 exports.sortBySegmentNumber = sortBySegmentNumber;
+exports.startReading = startReading;
+exports.stopReading = stopReading;
 exports.subscribeTopic = subscribeTopic;
 exports.toPage = toPage;
 exports.toPageRaw = toPageRaw;
@@ -28247,6 +29461,7 @@ exports.updateCommunity = updateCommunity;
 exports.updateMessage = updateMessage;
 exports.updatePost = updatePost;
 exports.updateStream = updateStream;
+exports.updateSubChannel = updateSubChannel;
 exports.updateUser = updateUser;
 exports.upsertInCache = upsertInCache;
 exports.votePoll = votePoll;