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

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,9 @@ 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',
+    'sessionStateChange',
+    // for internal use by accessTokenExpiryWatcher
+    'tokenExpired',
 ];
 const MQTT_EVENTS = [
     'connect',
@@ -1186,6 +1152,7 @@ const MQTT_EVENTS = [
     'close',
     'end',
     'reconnect',
+    'user.didGlobalBan',
 ];
 /** @hidden */
 const createEventEmitter = () => {
@@ -1203,12 +1170,16 @@ const createEventEmitter = () => {
  */
 const proxyWebsocketEvents = (ws, emitter) => {
     WS_EVENTS.forEach(event => {
-        ws.on(event, (param) => emitter.emit(event, param));
+        ws.on(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) => {
+            emitter.emit(event, params.length === 1 ? params[0] : params);
+        });
     });
     // @ts-ignore
     mqttClient.on('message', (topic, payload) => {
@@ -1292,6 +1263,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,26 +1279,58 @@ 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();
-    if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
+    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) {
+    var _a;
+    const { mqtt, emitter, token } = getActiveClient();
+    const accessToken = (_a = token === null || token === void 0 ? void 0 : token.accessToken) !== null && _a !== void 0 ? _a : '';
+    const user = getActiveUser();
+    if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
         mqttAccessToken = accessToken;
         mqttUserId = user._id;
         mqtt.connect({ accessToken: mqttAccessToken, userId: mqttUserId });
@@ -1422,12 +1426,32 @@ const createHttpTransport = (endpoint) => {
         httpsAgent: new HttpAgent.HttpsAgent(options),
         paramsSerializer: stringify,
     });
+    instance.interceptors.request.use(config => {
+        var _a;
+        // check global.ts for the extension of AxiosRequestConfig
+        const tokenExpiry = (_a = config.metadata) === null || _a === void 0 ? void 0 : _a.tokenExpiry;
+        if (tokenExpiry) {
+            if (Date.now() >= Date.parse(tokenExpiry)) {
+                return Object.assign(Object.assign({}, config), { cancelToken: new axios__default["default"].CancelToken(cancel => cancel('Token Expired')) });
+            }
+        }
+        return config;
+    });
     instance.interceptors.response.use(response => response, error => {
         var _a;
         const { response } = error;
         // eslint-disable-next-line no-console
         console.error((_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : error);
-        if (response)
+        // handle unauthorized request
+        if (response.data.code === 400100 /* Amity.ServerError.UNAUTHORIZED */) {
+            fireEvent('tokenTerminated', "terminated" /* Amity.SessionStates.TERMINATED */);
+        }
+        // handle request cancellation
+        if (axios__default["default"].isCancel(error)) {
+            fireEvent('tokenExpired', "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */);
+            throw new ASCError('Token expired', 800403 /* Amity.ClientError.TOKEN_EXPIRED */, "fatal" /* Amity.ErrorLevel.FATAL */);
+        }
+        if (response === null || response === void 0 ? void 0 : response.data)
             unwrapPayload(response.data);
     });
     return instance;
@@ -20162,7 +20186,7 @@ var MqttError;
     MqttError[MqttError["NOT_AUTHORIZED"] = 5] = "NOT_AUTHORIZED";
 })(MqttError || (MqttError = {}));
 function getMqttOptions(params) {
-    return Object.assign({ clean: false, clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`, protocolId: 'MQTT', protocolVersion: 4, reconnectPeriod: 0, will: {
+    return Object.assign({ clean: false, clientId: `mqttjs_ + ${Math.random().toString(16).substring(2, 10)}`, protocolId: 'MQTT', protocolVersion: 4, reconnectPeriod: 0, will: {
             topic: 'WillMsg',
             payload: 'Connection Closed abnormally..!',
             qos: 0,
@@ -20293,54 +20317,153 @@ const getFeedSettings = async () => {
     }));
 };
 
-const DEFAULT_DEBUG_SESSION = 'amity';
+const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+const COLLECTION_DEFAULT_CACHING_POLICY = 'cache_then_server';
+const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';
+const LIVE_OBJECT_ENABLE_CACHE_MESSAGE = 'For using Live Object feature you need to enable Cache!';
+const UNSYNCED_OBJECT_CACHED_AT_MESSAGE = 'Observing unsynced object is not supported by Live Object.';
+const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;
+const MINUTE = 60 * 1000;
+const ACCESS_TOKEN_WATCHER_INTERVAL = 10 * MINUTE;
+
+// TODO: find a way to uniquely identify the device
+/** @hidden */
+const VERSION = '11.0.0';
+/** @hidden */
+const getDeviceId = () => {
+    // here maybe put some auto detection of the device id based on if it's react or not?
+    // anyhow we let consumer branch out if they want, but it doesn't mean we shouldn't try to be nice
+    // and do things automatically
+    // https://www.npmjs.com/package/react-native-device-info#getuniqueid
+    // how to make sure that the react native package will not be included when build is for web
+    return `ascWebSdk#${Math.random().toString(16)}`;
+};
+/** @hidden */
+const getDeviceModel = () => {
+    var _a, _b;
+    if ((_a = safeProcess.versions) === null || _a === void 0 ? void 0 : _a.node)
+        return safeProcess.versions.node;
+    if (navigator)
+        return `${navigator.product.toLowerCase()}#${(_b = navigator.userAgent) !== null && _b !== void 0 ? _b : 'unknown_agent'}`;
+    return 'unknown_model';
+};
+/** @hidden */
+const getDeviceInfo = () => {
+    const model = getDeviceModel();
+    return {
+        version: VERSION,
+        // TODO: replace with: kind: process.versions ? 'node' : 'web', when backend has fixed this
+        kind: 'web',
+        model,
+    };
+};
+
+/*
+ * Session States cannot be set arbitarily.
+ * These are the possible new states based on the current state
+ * Check tech spec for details:
+ * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Session-State
+ */
+const sessisonStateTransitions = {
+    // notLoggedIn -> establishing
+    ["notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */]: ["establishing" /* Amity.SessionStates.ESTABLISHING */],
+    // terminated -> establishing
+    ["terminated" /* Amity.SessionStates.TERMINATED */]: ["establishing" /* Amity.SessionStates.ESTABLISHING */],
+    // establishing -> notLoggedIn, established
+    ["establishing" /* Amity.SessionStates.ESTABLISHING */]: [
+        "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */,
+        "established" /* Amity.SessionStates.ESTABLISHED */,
+    ],
+    /*
+     * established -> notLoggedIn, terminated, tokenExpired, establishing (for
+     * cases when logging in same user)
+     */
+    ["established" /* Amity.SessionStates.ESTABLISHED */]: [
+        "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */,
+        "terminated" /* Amity.SessionStates.TERMINATED */,
+        "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */,
+        "establishing" /* Amity.SessionStates.ESTABLISHING */,
+    ],
+    // tokenExpired -> establishing
+    ["tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */]: ["establishing" /* Amity.SessionStates.ESTABLISHING */],
+};
+const isValidStateChange = (prevState, nextState) => {
+    return sessisonStateTransitions[prevState].includes(nextState);
+};
 /**
- * ```js
- * import { createClient } from '@amityco/ts-sdk'
- * const client = createClient(apiKey, 'https://asc.server/', 'myClient')
- * ```
+ * Checks if a {@link Amity.Client} instance is connected to ASC servers
  *
- * Creates a new {@link Amity.Client} instance
  *
- * @param apiKey for the {@link Amity.Client} instance
- * @param apiRegion endpoint to connect to
- * @param apiEndpoint custom endpoint in case you don't want to use a preset endpoint
- * @param debugSession session's identifier for the client's logger instance
- * @returns A {@link Amity.Client} instance
+ * @param state the new session state
+ * @returns a success boolean if connected
+ *
+ * @category private
+ */
+const setSessionState = (state) => {
+    const client = getActiveClient();
+    client.log('client/api/setSessionState', state);
+    const { sessionState: prevState } = client;
+    if (prevState === state)
+        return false;
+    // check if transition is valid
+    if (!isValidStateChange(prevState, state)) {
+        throw new ASCError(`Session state cannot change from ${prevState} to ${state}`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+    client.sessionState = state;
+    fireEvent('sessionStateChange', state);
+    return true;
+};
+
+/**
+ * Retrieves a pair of {@link Amity.Tokens} necessary for connection
+ *
+ * @param params.userId The userId to use to issue a token
+ * @param params.displayName The user's displayName
+ * @param params.deviceId The user's device Id (can be manually set for native users)
+ * @param params.authToken The authentication token - necessary when network option is set to secure
+ * @return The accessToken for the given userId
  *
  * @category Client API
- * */
-const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAULT_DEBUG_SESSION, apiEndpoint, } = {}) => {
-    var _a, _b;
-    const log = createLogger(debugSession);
-    log('client/api/createClient', {
-        apiKey: apiKey.replace(/.{5}$/g, 'xxxxx'),
-        apiRegion,
+ * @hidden
+ */
+const getToken = async (params) => {
+    const client = getActiveClient();
+    client.log('client/api/getToken', params);
+    const deviceInfo = getDeviceInfo();
+    const { data } = await client.http.post('/api/v3/sessions', Object.assign(Object.assign({}, params), { deviceInfo }), {
+        // @ts-ignore
+        headers: { 'X-API-Key': client.apiKey },
     });
-    const httpEndpoint = (_a = apiEndpoint === null || apiEndpoint === void 0 ? void 0 : apiEndpoint.http) !== null && _a !== void 0 ? _a : computeUrl('http', apiRegion);
-    const mqttEndpoint = (_b = apiEndpoint === null || apiEndpoint === void 0 ? void 0 : apiEndpoint.mqtt) !== null && _b !== void 0 ? _b : computeUrl('mqtt', apiRegion);
-    const http = createHttpTransport(httpEndpoint);
-    const ws = createWebsocketTransport(httpEndpoint);
-    const mqtt = createMqttTransport(mqttEndpoint);
-    const emitter = createEventEmitter();
-    const client = {
-        version: `${VERSION$1}`,
-        apiKey,
-        log,
-        http,
-        ws,
-        mqtt,
-        emitter,
-        use: () => setActiveClient(client),
-        getFeedSettings,
-    };
-    try {
-        getActiveClient();
-    }
-    catch (_c) {
-        setActiveClient(client);
-    }
-    return client;
+    return data;
+};
+
+/**
+ * A util to set or refresh client token
+ *
+ * @param params.userId the user ID for the current session
+ * @param params.displayName the user's displayName for the current session
+ * @param params.deviceId Manual override of the user's device id (for device management)
+ * @param params.authToken The authentication token - necessary when network option is set to secure
+ * @returns token & user info
+ *
+ * @category private
+ * @async
+ */
+const setClientToken = async (params) => {
+    const client = getActiveClient();
+    // begin establishing session
+    setSessionState("establishing" /* Amity.SessionStates.ESTABLISHING */);
+    // @ts-ignore: in that particular case, typing can be
+    // ignored since we enforce default values just before.
+    const { accessToken, users, expiresAt, issuedAt, refreshToken } = await getToken(params);
+    // manually setup the token for http transport
+    client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
+    client.http.defaults.metadata = { tokenExpiry: expiresAt };
+    // manually setup the token for ws transport
+    client.ws.io.opts.query = { token: accessToken };
+    client.token = { accessToken, issuedAt, expiresAt };
+    setSessionState("established" /* Amity.SessionStates.ESTABLISHED */);
+    return { accessToken, users, refreshToken };
 };
 
 /**
@@ -20351,7 +20474,6 @@ const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAU
  *
  * Disconnects an {@link Amity.Client} instance from ASC servers
  *
- * @param client The {@link Amity.Client} instance to disconnect
  * @returns a success boolean if disconnected
  *
  * @category Client API
@@ -20370,42 +20492,30 @@ const disconnectClient = async () => {
     client.ws.removeAllListeners();
     client.mqtt.removeAllListeners();
     client.userId = undefined;
-    client.accessToken = undefined;
+    client.token = undefined;
+    client.http.defaults.headers.common.Authorization = '';
+    client.ws.io.opts.query = { token: '' };
+    /*
+     * for cases when session state is terminated (example on ban) or token expired,
+     * the terminating block will set session state to terminated or for the or
+     * in the case of expired token the same happens
+     *
+     * establishing state also ignored in cases where accessTokenExpiryWatcher
+     * calls renewal. There is a possibility that renewal will be called before
+     * disconnectClient finishes execution
+     */
+    if (client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */)
+        setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
+    /*
+     * Cache should be usable if tokenExpired
+     * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#SDK-usability-based-on-Session-State
+     */
+    if (client.sessionState !== "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */ && client.cache) {
+        client.cache = { data: {} };
+    }
     return !client.ws.connected;
 };
 
-// TODO: find a way to uniquely identify the device
-/** @hidden */
-const VERSION = '11.0.0';
-/** @hidden */
-const getDeviceId = () => {
-    // here maybe put some auto detection of the device id based on if it's react or not?
-    // anyhow we let consumer branch out if they want, but it doesn't mean we shouldn't try to be nice
-    // and do things automatically
-    // https://www.npmjs.com/package/react-native-device-info#getuniqueid
-    // how to make sure that the react native package will not be included when build is for web
-    return `ascWebSdk#${Math.random().toString(16)}`;
-};
-/** @hidden */
-const getDeviceModel = () => {
-    var _a, _b;
-    if ((_a = safeProcess.versions) === null || _a === void 0 ? void 0 : _a.node)
-        return safeProcess.versions.node;
-    if (navigator)
-        return `${navigator.product.toLowerCase()}#${(_b = navigator.userAgent) !== null && _b !== void 0 ? _b : 'unknown_agent'}`;
-    return 'unknown_model';
-};
-/** @hidden */
-const getDeviceInfo = () => {
-    const model = getDeviceModel();
-    return {
-        version: VERSION,
-        // TODO: replace with: kind: process.versions ? 'node' : 'web', when backend has fixed this
-        kind: 'web',
-        model,
-    };
-};
-
 /**
  * Ingest a payload (v3) into the cache
  *
@@ -20457,26 +20567,17 @@ const createUserEventSubscriber = (event, callback) => {
 const onUserDeleted = (callback) => createUserEventSubscriber('user.deleted', callback);
 
 /**
- * Retrieves a pair of {@link Amity.Tokens} necessary for connection
+ * Terminates {@link Amity.Client} instance
  *
- * @param userId The userId to use to issue a token
- * @param displayName The user's displayName
- * @param deviceId The user's device Id (can be manually set for native users)
- * @param authToken The authentication token - necessary when network option is set to secure
- * @return The accessToken for the given userId
  *
- * @category Client API
- * @hidden
+ *
+ * @category private
  */
-const getToken = async (params) => {
+const terminateClient = () => {
     const client = getActiveClient();
-    client.log('client/api/getToken', params);
-    const deviceInfo = await getDeviceInfo();
-    const { data } = await client.http.post('/v1/device', Object.assign(Object.assign({}, params), { deviceInfo }), {
-        // @ts-ignore
-        headers: { 'X-API-Key': client.apiKey },
-    });
-    return data;
+    setSessionState("terminated" /* Amity.SessionStates.TERMINATED */);
+    client.sessionHandler = undefined;
+    disconnectClient();
 };
 
 const EVENTS = [
@@ -20551,12 +20652,71 @@ const onClientDisconnected = (callback) => {
  * @category Client Events
  */
 const onClientBanned = (callback) => {
-    return onConnectionError(({ code }) => {
-        code === 400312 /* Amity.ServerError.GLOBAL_BAN */ && callback();
-    });
+    const client = getActiveClient();
+    return createEventSubscriber(client, `client/onConnectionError(user.didGlobalBan)`, 'user.didGlobalBan', callback);
+};
+
+/**
+ * ```js
+ * import { onSessionStateChange } from '@amityco/ts-sdk'
+ * const dispose = onSessionStateChange((state: Amity.SessionStates) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} has a session state change
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+const onSessionStateChange = (callback) => {
+    const client = getActiveClient();
+    return createEventSubscriber(client, `client/onSessionStateChange`, 'sessionStateChange', callback);
+};
+
+/**
+ * ```js
+ * import { onTokenExpired } from '@amityco/ts-sdk'
+ * const dispose = onTokenExpired((state: Amity.SessionStates.TOKEN_EXPIRED) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} session state has expired
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category private
+ */
+const onTokenExpired = (callback) => {
+    const client = getActiveClient();
+    return createEventSubscriber(client, `client/onTokenExpired`, 'tokenExpired', callback);
+};
+
+/**
+ *
+ * Fired when any {@link Amity.Client} session state has terminated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category private
+ */
+const onTokenTerminated = (callback) => {
+    const client = getActiveClient();
+    return createEventSubscriber(client, `client/onTokenTerminated`, 'tokenTerminated', callback);
 };
 
 /* eslint-disable no-param-reassign */
+/*
+ * declared earlier to accomodate case when logging in with a different user
+ * than the one already connected, in which case the existing subscriptions need
+ * to be cleared
+ */
+const subscriptions = [];
 /**
  * ```js
  * import { connectClient } from '@amityco/ts-sdk/client/api'
@@ -20577,44 +20737,258 @@ const onClientBanned = (callback) => {
  * @category Client API
  * @async
  */
-const connectClient = async (params, config) => {
-    var _a;
+const connectClient = async (params, sessionHandler, config) => {
+    var _a, _b, _c;
     const client = getActiveClient();
-    client.log('client/api/connectClient', Object.assign({ apiKey: client.apiKey }, params));
+    let unsubWatcher;
+    client.log('client/api/connectClient', Object.assign({ apiKey: client.apiKey, sessionState: client.sessionState }, params));
+    // if connecting to a different userId than the one that is connected currently
+    if (client.userId && client.userId !== params.userId) {
+        await disconnectClient();
+        // Remove subscription to ban and delete
+        subscriptions.forEach(fn => fn());
+    }
     // default values
     (_a = params.deviceId) !== null && _a !== void 0 ? _a : (params.deviceId = getDeviceId());
-    // @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
-    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
-    proxyWebsocketEvents(client.ws, client.emitter);
-    // TODO: in phase 2, this should not be necessary. we should have WS
-    // to be connected "on demand" rather than "by default"
-    await new Promise(resolve => {
-        client.ws.once('connect', resolve);
-        client.ws.open();
-    });
-    client.userId = params.userId;
-    client.accessToken = accessToken;
-    setActiveUser(users[0]);
-    if ((config === null || config === void 0 ? void 0 : config.disableRTE) !== true) {
+    try {
+        // @ts-ignore: in that particular case, typing can be
+        // ignored since we enforce default values just before.
+        const { users } = await setClientToken(params);
+        // FIXME: events are duplicated if connectClient is called few times without disconnectClient
+        // wire websocket events to our event emitter
+        proxyWebsocketEvents(client.ws, client.emitter);
+        // TODO: in phase 2, this should not be necessary. we should have WS
+        // to be connected "on demand" rather than "by default"
+        await new Promise(resolve => {
+            client.ws.once('connect', resolve);
+            client.ws.open();
+        });
+        client.userId = params.userId;
+        client.sessionHandler = sessionHandler;
+        /*
+         * Cannot push to subscriptions as watcher needs to continue working even if
+         * token expires
+         */
+        unsubWatcher = client.accessTokenExpiryWatcher((_b = client.token) === null || _b === void 0 ? void 0 : _b.issuedAt, (_c = client.token) === null || _c === void 0 ? void 0 : _c.expiresAt, sessionHandler);
+        setActiveUser(users[0]);
+    }
+    catch (error) {
+        /*
+         * if getting token failed session state reverts to initial state when app
+         * is first launched
+         */
+        setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
+        // pass error down tree so the calling function handle it
+        throw error;
+    }
+    if ((config === null || config === void 0 ? void 0 : config.disableRTE) !== true) {
         subscribeTopic(getNetworkTopic());
+        subscribeTopic(getSmartFeedChannelTopic());
+        subscribeTopic(getSmartFeedSubChannelTopic());
+        subscribeTopic(getSmartFeedMessageTopic());
+        // subscribing to user topic is necessary to handle ban event
+        subscribeTopic(getUserTopic(getActiveUser()));
     }
-    const subscriptions = [
-        onClientBanned(() => {
-            disconnectClient();
+    subscriptions.push(
+    // GLOBAL_BAN
+    onClientBanned((_) => {
+        terminateClient();
+        subscriptions.forEach(fn => fn());
+        unsubWatcher();
+    }), onTokenTerminated(_ => {
+        terminateClient();
+        subscriptions.forEach(fn => fn());
+        unsubWatcher();
+    }), onUserDeleted((user) => {
+        if (user.userId === client.userId) {
+            terminateClient();
             subscriptions.forEach(fn => fn());
-        }),
-        onUserDeleted(() => null),
-    ];
+            unsubWatcher();
+        }
+    }), onTokenExpired(state => {
+        setSessionState(state);
+        disconnectClient();
+        subscriptions.forEach(fn => fn());
+    }), onUserDeleted(() => null));
     return client.ws.connected;
 };
 
+/*
+ * Renewal defintion accepted by SessionHandler interface
+ *
+ * Tech Spec:
+ * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Session-Handler
+ *
+ * @category private
+ */
+const renewal = () => {
+    let tokenRenewed = false;
+    let renewTimeoutId;
+    const client = getActiveClient();
+    client.log('initiating access token renewal');
+    /*
+     * Renews a token if it is hasn't been renewed before. Also marks token as
+     * renewed once done
+     * Per instance of Renewal, only one renewal is allowed
+     */
+    const renewToken = async (authToken) => {
+        const { userId, displayName } = getActiveUser();
+        const deviceId = getDeviceId();
+        const params = { userId, displayName, authToken, deviceId };
+        if (client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
+            // sessionHandler will never be empty when renewal is instantiatied
+            await connectClient(params, client.sessionHandler);
+        }
+        else {
+            // about to expire
+            // @ts-ignore: in that particular case, typing can be
+            // ignored since we enforce default values just before.
+            await setClientToken(params);
+        }
+        tokenRenewed = true;
+        if (renewTimeoutId)
+            clearTimeout(renewTimeoutId);
+    };
+    return {
+        renew: () => {
+            if (tokenRenewed) {
+                console.log("'renew' method can be called only once per renewal instance");
+                return;
+            }
+            renewToken();
+        },
+        renewWithAuthToken: (authToken) => {
+            if (tokenRenewed) {
+                console.log("'renewWithAuthToken' method can be called only once per renewal instance");
+                return;
+            }
+            renewToken(authToken);
+        },
+        unableToRetrieveAuthToken: () => {
+            renewTimeoutId = setTimeout(() => {
+                var _a;
+                (_a = client.sessionHandler) === null || _a === void 0 ? void 0 : _a.sessionWillRenewAccessToken(renewal());
+            }, ACCESS_TOKEN_WATCHER_INTERVAL);
+        },
+    };
+};
+
+const ABOUT_TO_EXPIRE_THRESHOLD = 80 / 100;
+const COMPENSATED_DELAY = 5 * MINUTE;
+/*
+ * a helper function to check if the token has expires
+ *
+ * @param token to be checked
+ * @returns boolean indicating if token expires
+ *
+ * @category private
+ */
+const isExpired = (expiresAt) => Date.now() > Date.parse(expiresAt) - COMPENSATED_DELAY;
+/*
+ * a helper function to check if the token is about to expire
+ *
+ * @param token to be checked
+ * @returns boolean indicating if token is aboutToExpire
+ *
+ * @category private
+ */
+const isAboutToExpire = (expiresAt, issuedAt) => {
+    const expires = Date.parse(expiresAt);
+    const issued = Date.parse(issuedAt);
+    const now = Date.now();
+    const duration = expires - issued - COMPENSATED_DELAY;
+    const aboutToExpireAt = issued + duration * ABOUT_TO_EXPIRE_THRESHOLD;
+    return now > aboutToExpireAt && now < expires;
+};
+/*
+ * Monitors time to expire of token and updates session state to aboutToExpire
+ *
+ * @returns intervalId to be cleared after trigger
+ *
+ * @category private
+ */
+const accessTokenExpiryWatcher = (expiresAt, issuedAt, sessionHandler) => {
+    const interval = setInterval(() => {
+        if (isExpired(expiresAt)) {
+            /*
+             * the event handler will take care of updating session state
+             * Note, this will also clear the interval id, so this event will only be
+             * fired once
+             */
+            fireEvent('tokenExpired', "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */);
+            /*
+             * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Automatically-initiate-renewal-flow
+             *
+             * Why sechduled task?
+             * Since fireEvent is scheduled, it will be called
+             * after sessionHandler leading to an invalid state change from
+             * establishing to tokenExpired
+             */
+            scheduleTask(() => sessionHandler.sessionWillRenewAccessToken(renewal()));
+            return;
+        }
+        if (isAboutToExpire(issuedAt, expiresAt)) {
+            sessionHandler.sessionWillRenewAccessToken(renewal());
+        }
+    }, ACCESS_TOKEN_WATCHER_INTERVAL);
+    return () => clearInterval(interval);
+};
+
+const DEFAULT_DEBUG_SESSION = 'amity';
+/**
+ * ```js
+ * import { createClient } from '@amityco/ts-sdk'
+ * const client = createClient(apiKey, 'https://asc.server/', 'myClient')
+ * ```
+ *
+ * Creates a new {@link Amity.Client} instance
+ *
+ * @param apiKey for the {@link Amity.Client} instance
+ * @param apiRegion endpoint to connect to
+ * @param apiEndpoint custom endpoint in case you don't want to use a preset endpoint
+ * @param param.debugSession session's identifier for the client's logger instance
+ * @returns A {@link Amity.Client} instance
+ *
+ * @category Client API
+ * */
+const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAULT_DEBUG_SESSION, apiEndpoint, } = {}) => {
+    var _a, _b;
+    const log = createLogger(debugSession);
+    log('client/api/createClient', {
+        apiKey: apiKey.replace(/.{5}$/g, 'xxxxx'),
+        apiRegion,
+    });
+    const httpEndpoint = (_a = apiEndpoint === null || apiEndpoint === void 0 ? void 0 : apiEndpoint.http) !== null && _a !== void 0 ? _a : computeUrl('http', apiRegion);
+    const mqttEndpoint = (_b = apiEndpoint === null || apiEndpoint === void 0 ? void 0 : apiEndpoint.mqtt) !== null && _b !== void 0 ? _b : computeUrl('mqtt', apiRegion);
+    const http = createHttpTransport(httpEndpoint);
+    const ws = createWebsocketTransport(httpEndpoint);
+    const mqtt = createMqttTransport(mqttEndpoint);
+    const emitter = createEventEmitter();
+    const sessionState = "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */;
+    const sessionHandler = undefined;
+    const client = {
+        version: `${VERSION$1}`,
+        apiKey,
+        log,
+        http,
+        ws,
+        mqtt,
+        emitter,
+        accessTokenExpiryWatcher,
+        use: () => setActiveClient(client),
+        sessionState,
+        sessionHandler,
+        getFeedSettings,
+    };
+    try {
+        return getActiveClient();
+    }
+    catch (_c) {
+        setActiveClient(client);
+    }
+    return client;
+};
+
 /**
  * ```js
  * import { isConnected } from '@amityco/ts-sdk'
@@ -20956,23 +21330,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'
@@ -21041,61 +21398,74 @@ const onUserUnflagged = (callback) => createUserEventSubscriber('user.unflagged'
  */
 const onUserFlagCleared = (callback) => createUserEventSubscriber('user.flagCleared', callback);
 
-const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
-const COLLECTION_DEFAULT_CACHING_POLICY = 'cache_then_server';
-const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';
-const LIVE_OBJECT_ENABLE_CACHE_MESSAGE = 'For using Live Object feature you need to enable Cache!';
-const UNSYNCED_OBJECT_CACHED_AT_MESSAGE = 'Observing unsynced object is not supported by Live Object.';
-const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;
+/**
+ * ```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 { liveUser } from '@amityco/ts-sdk'
+ * 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 +21879,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 +21888,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 +22006,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 +22021,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 +22071,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 +22135,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 +22177,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 +22195,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 +22221,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 +22242,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 +22268,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 +22313,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 +22330,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 +22345,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 +22354,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 +22369,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 +22379,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 +22399,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 +22431,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 +22742,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'),
             } }),
     });
@@ -22548,10 +23044,62 @@ const leaveCommunity = async (communityId) => {
 };
 
 /**
- * ```js
- * import { queryCommunityMembers } from '@amityco/ts-sdk'
- * const communityMembers = await queryCommunityMembers({ communityId: 'foo' })
- * ```
+ * 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'
+ * const communityMembers = await queryCommunityMembers({ communityId: 'foo' })
+ * ```
  *
  * Queries a paginable list of {@link Amity.CommunityUser} objects
  *
@@ -22564,17 +23112,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 +23152,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 +23883,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 +23910,7 @@ const addReaction = async (referenceType, referenceId, reactionName) => {
         referenceId,
         referenceType,
         reactionName,
+        referenceVersion: referenceType === 'message' ? 5 : undefined,
     });
     if (client.cache) {
         const model = pullFromCache([
@@ -23440,7 +23987,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 +24505,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 +24519,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 +24552,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 +24566,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 +24599,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 +24610,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 +24655,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 +24666,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 +24736,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 +24773,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 +24820,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,16 +24859,26 @@ 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);
+        ingestInCache(referenceType === 'message' ? prepareMessagePayload(data) : data);
+    if (referenceType === 'message') {
+        fireEvent('message.unflagged', data);
+    }
+    else {
+        // @ts-ignore
+        fireEvent(`${referenceType}.unflagged`, data);
+    }
     return !!data;
 };
 
@@ -24324,26 +24900,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 +25074,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 +25152,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 +25304,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 +25329,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 +25355,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 +25401,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 +25428,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 +25510,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 +25542,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 +25650,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 +25675,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 +25706,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 +25727,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 +25752,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 +25806,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 +25833,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 +25860,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 +25887,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 +25929,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,44 +25964,384 @@ 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) => {
+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 });
+            }
+            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);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'message/onMessageCreated', 'message.created', filter),
+        createEventSubscriber(client, 'local.message.created', 'local.message.created', payload => callback(payload.messages[0])),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { onMessageUpdated } from '@amityco/ts-sdk'
+ * const dispose = onMessageUpdated(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * 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]))
@@ -25324,21 +26387,17 @@ const liveChannels = (params, callback, config) => {
             error: data.error,
         });
     };
-    const realtimeRouter = (channel, action) => {
+    const realtimeRouter = (action) => (channel) => {
         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) {
+        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);
     };
@@ -25363,7 +26422,7 @@ const liveChannels = (params, callback, config) => {
             responder(data);
         }, queryOptions(policy));
     };
-    disposers.push(onChannelCreated(channel => realtimeRouter(channel, 'onCreate')), onChannelDeleted(channel => realtimeRouter(channel, 'onDelete')), onChannelUpdated(channel => realtimeRouter(channel, 'onUpdate')));
+    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`);
@@ -25381,184 +26440,655 @@ const liveChannels = (params, callback, config) => {
  * }, 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 +27112,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 +27174,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 +27188,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 +27216,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 +27236,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 +27271,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 +27284,7 @@ const liveMessages = (params, callback, config) => {
  * import { observeMessage } from '@amityco/ts-sdk'
  *
  * let message = {}
+ *
  * const unsub = observeMessage(messageId, updated => message = updated)
  * ```
  *
@@ -25796,25 +27331,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 +27413,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 +28468,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 +28503,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 +28558,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 +28593,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 +28731,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 +28742,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 +28792,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 +28934,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 +28973,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`);
@@ -28004,9 +29559,9 @@ const onStreamRecorded = (callback) => {
  */
 const createUserToken = async (apiKey, apiRegion, params) => {
     const deviceId = getDeviceId();
-    const deviceInfo = await getDeviceInfo();
+    const deviceInfo = getDeviceInfo();
     const http = createHttpTransport(computeUrl('http', apiRegion));
-    const { data } = await http.post('/api/v3/sessions', Object.assign(Object.assign({}, params), { deviceId, deviceInfo: Object.assign(Object.assign({}, deviceInfo), { model: 'token management API on TS-SDK' }) }), { headers: { 'X-API-Key': apiKey } });
+    const { data } = await http.post('/api/v4/sessions', Object.assign(Object.assign({}, params), { deviceId, deviceInfo: Object.assign(Object.assign({}, deviceInfo), { model: 'token management API on TS-SDK' }) }), { headers: { 'X-API-Key': apiKey } });
     return { accessToken: data.accessToken };
 };
 
@@ -28045,6 +29600,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 +29614,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 +29628,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 +29640,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 +29651,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 +29678,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 +29688,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 +29715,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 +29744,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;
@@ -28192,11 +29765,14 @@ exports.onReactionAdded = onReactionAdded;
 exports.onReactionRemoved = onReactionRemoved;
 exports.onReactorAdded = onReactorAdded;
 exports.onReactorRemoved = onReactorRemoved;
+exports.onSessionStateChange = onSessionStateChange;
 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,12 +29797,14 @@ exports.queryPosts = queryPosts;
 exports.queryReactions = queryReactions;
 exports.queryRoles = queryRoles;
 exports.queryStreams = queryStreams;
+exports.querySubChannels = querySubChannels;
 exports.queryUsers = queryUsers;
 exports.removeChannelMembers = removeChannelMembers;
 exports.removeChannelMembersRole = removeChannelMembersRole;
 exports.removeCommunityMembers = removeCommunityMembers;
 exports.removeCommunityMembersRoles = removeCommunityMembersRoles;
 exports.removeReaction = removeReaction;
+exports.renewal = renewal;
 exports.restoreCache = restoreCache;
 exports.runQuery = runQuery;
 exports.sortByChannelSegment = sortByChannelSegment;
@@ -28235,6 +29813,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 +29827,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;