@amityco/ts-sdk 0.0.1-bc64ebf.0 → 0.0.1-bd9dae9.0

package/dist/index.esm.js

@@ -1,12 +1,85 @@
 import { encode, decode } from 'js-base64';
-import mitt from 'mitt';
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import mitt from 'mitt';
 import debug from 'debug';
 import axios from 'axios';
+import qs from 'qs';
 import HttpAgent, { HttpsAgent } from 'agentkeepalive';
 import io from 'socket.io-client';
 import nativeIdGenerator from 'react-native-uuid';
 
+const CommunityPostSettings = Object.freeze({
+    ONLY_ADMIN_CAN_POST: 'ONLY_ADMIN_CAN_POST',
+    ADMIN_REVIEW_POST_REQUIRED: 'ADMIN_REVIEW_POST_REQUIRED',
+    ANYONE_CAN_POST: 'ANYONE_CAN_POST',
+});
+const CommunityPostSettingMaps = Object.freeze({
+    ONLY_ADMIN_CAN_POST: {
+        needApprovalOnPostCreation: false,
+        onlyAdminCanPost: true,
+    },
+    ADMIN_REVIEW_POST_REQUIRED: {
+        needApprovalOnPostCreation: true,
+        onlyAdminCanPost: false,
+    },
+    ANYONE_CAN_POST: {
+        needApprovalOnPostCreation: false,
+        onlyAdminCanPost: false,
+    },
+});
+const DefaultCommunityPostSetting = 'ONLY_ADMIN_CAN_POST';
+
+const ContentFeedType = Object.freeze({
+    STORY: 'story',
+    CLIP: 'clip',
+    CHAT: 'chat',
+    POST: 'post',
+    MESSAGE: 'message',
+});
+
+const FileType = Object.freeze({
+    FILE: 'file',
+    IMAGE: 'image',
+    VIDEO: 'video',
+});
+const VideoResolution = Object.freeze({
+    '1080P': '1080p',
+    '720P': '720p',
+    '480P': '480p',
+    '360P': '360p',
+    ORIGINAL: 'original',
+});
+const VideoTranscodingStatus = Object.freeze({
+    UPLOADED: 'uploaded',
+    TRANSCODING: 'transcoding',
+    TRANSCODED: 'transcoded',
+    TRANSCODE_FAILED: 'transcodeFailed',
+});
+const VideoSize = Object.freeze({
+    LOW: 'low',
+    MEDIUM: 'medium',
+    HIGH: 'high',
+    ORIGINAL: 'original',
+});
+
+const MessageContentType = Object.freeze({
+    TEXT: 'text',
+    IMAGE: 'image',
+    FILE: 'file',
+    VIDEO: 'video',
+    AUDIO: 'audio',
+    CUSTOM: 'custom',
+});
+
+const PostContentType = Object.freeze({
+    TEXT: 'text',
+    IMAGE: 'image',
+    FILE: 'file',
+    VIDEO: 'video',
+    LIVESTREAM: 'liveStream',
+    POLL: 'poll',
+});
+
 var _a$1;
 /* eslint-disable no-undef */
 const theGlobal = 
@@ -211,7 +284,7 @@ const CRITERIAS = {
     channel: ['channelId', 'rateLimit'],
     channelUsers: ['channelId', 'userId', 'membership'],
     message: ['messageId'],
-    community: ['communityId', 'onlyAdminCanPost'],
+    community: ['communityId', 'postSetting'],
     category: ['categoryId'],
     communityUsers: ['userId', 'communityId', 'communityMembership'],
     post: ['postId', 'feedId'],
@@ -282,6 +355,78 @@ const PAYLOAD2MODEL = {
     followCounts: 'followCount',
 };
 
+// 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
@@ -340,7 +485,7 @@ const isLocal = (model) => {
  *
  * @hidden
  */
-const isFresh = (model, lifeSpan = 0) => {
+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;
 };
@@ -374,12 +519,10 @@ const createQuery = (func, ...args) => ({ func, args });
  *
  * @category Query
  */
-const queryOptions = (policy, lifeSpan = 2 * 60 * 1000) => {
+const queryOptions = (policy, lifeSpan = CACHE_LIFESPAN) => {
     if (policy === 'cache_only')
         return { lifeSpan: Infinity };
-    if (policy === 'server_only')
-        return { lifeSpan: 0 };
-    return { lifeSpan };
+    return { lifeSpan: lifeSpan < CACHE_LIFESPAN ? CACHE_LIFESPAN : lifeSpan };
 };
 /**
  * ```js
@@ -400,8 +543,9 @@ const queryOptions = (policy, lifeSpan = 2 * 60 * 1000) => {
  */
 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) && options.lifeSpan !== 0) {
+    if (isOffline(func)) {
         try {
             local = isMutator(func) ? func.optimistically(...args) : func.locally(...args);
         }
@@ -412,7 +556,7 @@ const runQuery = ({ func, args }, callback, options = queryOptions('cache_then_s
                 error,
             }));
         }
-        const shouldAbort = isCachable(local) && isFresh(local, options.lifeSpan);
+        const shouldAbort = isCachable(local) && isFresh(local, lifeSpan);
         callback === null || callback === void 0 ? void 0 : callback(createSnapshot(local, {
             origin: 'local',
             loading: !(isFetcher(func) && shouldAbort),
@@ -479,53 +623,6 @@ function createSnapshot(data, options) {
     return Object.assign(Object.assign({}, options), { data });
 }
 
-// Note:
-// this file should contain a suite of filtering utilities to help the
-// local version of the query functions.
-/**
- * Filter a given collection with strict equality against a param
- *
- * @param collection the collection to filter
- * @param key the key of the collection's items to challenge
- * @param value the expected value
- * @returns a filtered collection with items only matching the criteria
- *
- * @hidden
- */
-const filterByPropEquality = (collection, key, value) => (value !== undefined ? collection.filter(item => item[key] === value) : collection);
-
-// Note:
-// this file should contain a suite of sorting utilities to help the
-// local version of the query functions.
-/**
- * Alphabetic sorting of objects having a displayName
- */
-const sortByDisplayName = ({ displayName: a }, { displayName: b }) => {
-    if (a === b)
-        return 0;
-    return a < b ? -1 : 1;
-};
-/**
- * Sorting a collection by their apparition order (oldest first)
- */
-const sortByChannelSegment = ({ channelSegment: a }, { channelSegment: b }) => a - b;
-/**
- * Sorting a collection by their apparition order (oldest first)
- */
-const sortBySegmentNumber = ({ segmentNumber: a }, { segmentNumber: b }) => a - b;
-/**
- * Sorting a collection by its oldest items
- */
-const sortByFirstCreated = ({ createdAt: a }, { createdAt: b }) => new Date(a).valueOf() - new Date(b).valueOf();
-/**
- * Sorting a collection by its newest items
- */
-const sortByLastCreated = ({ createdAt: a }, { createdAt: b }) => new Date(b).valueOf() - new Date(a).valueOf();
-/**
- * Sorting a collection by the items with most recent activity
- */
-const sortByLastActivity = ({ lastActivity: a }, { lastActivity: b }) => new Date(b).valueOf() - new Date(a).valueOf();
-
 /* eslint-disable max-classes-per-file */
 /**
  * Generic ASC error
@@ -615,264 +712,70 @@ const setActiveClient = (client) => {
     activeClient = client;
 };
 
-/* eslint-disable @typescript-eslint/ban-types */
-let tasks = [];
-let timer;
 /**
- * Add a function to run just before the next tick
+ * ```js
+ * import { enableCache } from '@amityco/ts-sdk'
+ * enableCache()
+ * ```
  *
- * @param task function to schedule for later execution
+ * Adds a new {@link Amity.Cache} object to
+ * an {@link Amity.Client} instance
+ *
+ * @param prevState a previous state of cache instance (useful for SSR)
+ * @param persistIf a function to determine if an entry inserted in cache
+ * is destined to be also saved in the persistent storage when
+ * calling {@link backupCache}
+ *
+ * @category Cache API
  */
-const scheduleTask = (task) => {
-    clearTimeout(timer);
-    tasks.push(task);
-    timer = setTimeout(() => {
-        tasks.forEach(fn => fn());
-        tasks = [];
-    }, 0);
+const enableCache = (prevState = {}, persistIf) => {
+    const client = getActiveClient();
+    if (client.cache)
+        return;
+    client.log('cache/api/enableCache');
+    client.cache = { data: prevState, persistIf };
 };
 
-/* eslint-disable @typescript-eslint/no-unused-vars */
-// need to sync up the list
-const WS_EVENTS = [
-    'disconnected',
-    'error',
-    'connect_error',
-    'reconnect_error',
-    'reconnect_failed',
-    'v3.channel.didUpdate',
-    'v3.channel.didUpdate',
-    'v3.channel.didJoin',
-    'v3.channel.didLeave',
-    'v3.channel.didAddUsers',
-    'v3.channel.didRemoveUsers',
-    'v3.channel.didBan',
-    'v3.channel.didUnban',
-    'v3.message.didCreate',
-    'v3.message.didUpdate',
-    'v3.message.didDelete',
-];
-const MQTT_EVENTS = [
-    'connect',
-    'message',
-    'disconnect',
-    'error',
-    'close',
-    'end',
-    'reconnect',
-];
-/** @hidden */
-const createEventEmitter = () => {
-    return mitt();
-};
 /**
- * Wraps the websocket events into the client's event emitter for
- * abstraction of transport.
+ * ```js
+ * import { disableCache } from '@amityco/ts-sdk'
+ * disableCache()
+ * ```
  *
- * @param ws A websocket connection to listen from
- * @param emitter An event emitter to wire the events to
+ * Wipes the existing {@link Amity.Cache} object attached to
+ * an {@link Amity.Client} instance
  *
- * @category Transport
- * @hidden
+ * @category Cache API
  */
-const proxyWebsocketEvents = (ws, emitter) => {
-    WS_EVENTS.forEach(event => {
-        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));
-    });
-    // @ts-ignore
-    mqttClient.on('message', (topic, payload) => {
-        const message = JSON.parse(payload.toString());
-        emitter.emit(message.eventType, message.data);
-    });
-};
+const disableCache = () => {
+    const client = getActiveClient();
+    if (!client.cache)
+        return;
+    client.log('cache/api/disableCache');
+    // we do this so that testing if cache is enabled
+    // is only `if (client.cache)
+    delete client.cache;
+};
+
 /**
- * Standardize the subscription of SSE through web sockets
+ * ```js
+ * import { restoreCache } from '@amityco/ts-sdk'
+ * const success = await restoreCache()
+ * ```
  *
- * @param client The current client for which to subscribe the event to
- * @param namespace A unique name for the logger
- * @param event The websocket event name
- * @param fn A wrapper for the callback.
- * @returns A dispose function to unsubscribe to the event
+ * Reads a previously saved {@link Amity.Cache} from a persistent storage,
+ * and inserts it into the current {@link Amity.Cache} instance.
  *
- * @category Transport
- * @hidden
- */
-const createEventSubscriber = (client, namespace, event, fn) => {
-    const { log, emitter } = client;
-    const timestamp = Date.now();
-    log(`${namespace}(tmpid: ${timestamp}) > listen`);
-    const handler = (...payload) => {
-        log(`${namespace}(tmpid: ${timestamp}) > trigger`, payload);
-        fn(...payload);
-    };
-    emitter.on(event, handler);
-    return () => {
-        log(`${namespace}(tmpid: ${timestamp}) > dispose`);
-        emitter.off(event, handler);
-    };
-};
-/**
- * Wrapper around dispatch event
+ * The strategy for persistent storage will depend on the runtime,
+ * which is supported by @react-native-async-storage/async-storage.
  *
- * @hidden
- */
-const fireEvent = (event, payload) => {
-    const { emitter } = getActiveClient();
-    scheduleTask(() => {
-        emitter.emit(event, payload);
-    });
-};
-
-let activeUser = null;
-/**
- * for internal use
- */
-const getActiveUser = () => {
-    if (!activeUser) {
-        throw new ASCError('Connect client first', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "fatal" /* Amity.ErrorLevel.FATAL */);
-    }
-    return activeUser;
-};
-const setActiveUser = (user) => {
-    activeUser = {
-        _id: user._id,
-        userId: user.userId,
-        path: user.path,
-    };
-};
-
-var SubscriptionLevels;
-(function (SubscriptionLevels) {
-    SubscriptionLevels["COMMUNITY"] = "community";
-    SubscriptionLevels["POST"] = "post";
-    SubscriptionLevels["COMMENT"] = "comment";
-    SubscriptionLevels["POST_AND_COMMENT"] = "post_and_comment";
-    SubscriptionLevels["USER"] = "user";
-})(SubscriptionLevels || (SubscriptionLevels = {}));
-const getCommunityUserTopic = (path, level) => {
-    switch (level) {
-        case 'post':
-            return `${path}/post/+`;
-        case 'comment':
-            return `${path}/post/+/comment/+`;
-        case 'post_and_comment':
-            return `${path}/post/#`;
-        default:
-            return path;
-    }
-};
-const getCommunityTopic = ({ path }, level = SubscriptionLevels.COMMUNITY) => getCommunityUserTopic(path, level);
-const getUserTopic = ({ path }, level = SubscriptionLevels.USER) => getCommunityUserTopic(level === SubscriptionLevels.USER ? path : path.replace(/^(\w*)/, '$1/social'), level);
-const getPostTopic = ({ path }, level = SubscriptionLevels.POST) => {
-    switch (level) {
-        case 'comment':
-            return `${path}/comment/+`;
-        default:
-            return path;
-    }
-};
-const getCommentTopic = ({ path }) => {
-    return path;
-};
-const getMyFollowersTopic = () => {
-    const user = getActiveUser();
-    const [networkId] = user.path.split('/user/');
-    return `${networkId}/membership/${user._id}/+/+`;
-};
-const getMyFollowingsTopic = () => {
-    const user = getActiveUser();
-    const [networkId] = user.path.split('/user/');
-    return `${networkId}/membership/+/${user._id}/+`;
-};
-/** @hidden */
-const getNetworkTopic = () => {
-    const user = getActiveUser();
-    const [networkId] = user.path.split('/user/');
-    return networkId;
-};
-let mqttAccessToken;
-let mqttUserId;
-function subscribeTopic(topic, callback) {
-    const { mqtt, emitter, accessToken } = getActiveClient();
-    const user = getActiveUser();
-    if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
-        mqttAccessToken = accessToken;
-        mqttUserId = user._id;
-        mqtt.connect({ accessToken: mqttAccessToken, userId: mqttUserId });
-        proxyMqttEvents(mqtt, emitter);
-    }
-    return mqtt.subscribe(topic, callback);
-}
-
-/**
- * ```js
- * import { enableCache } from '@amityco/ts-sdk'
- * enableCache()
- * ```
- *
- * Adds a new {@link Amity.Cache} object to
- * an {@link Amity.Client} instance
- *
- * @param prevState a previous state of cache instance (useful for SSR)
- * @param persistIf a function to determine if an entry inserted in cache
- * is destined to be also saved in the persistent storage when
- * calling {@link backupCache}
- *
- * @category Cache API
- */
-const enableCache = (prevState = {}, persistIf) => {
-    const client = getActiveClient();
-    if (client.cache)
-        return;
-    client.log('cache/api/enableCache');
-    client.cache = { data: prevState, persistIf };
-};
-
-/**
- * ```js
- * import { disableCache } from '@amityco/ts-sdk'
- * disableCache()
- * ```
- *
- * Wipes the existing {@link Amity.Cache} object attached to
- * an {@link Amity.Client} instance
- *
- * @category Cache API
- */
-const disableCache = () => {
-    const client = getActiveClient();
-    if (!client.cache)
-        return;
-    client.log('cache/api/disableCache');
-    // we do this so that testing if cache is enabled
-    // is only `if (client.cache)
-    delete client.cache;
-};
-
-/**
- * ```js
- * import { restoreCache } from '@amityco/ts-sdk'
- * const success = await restoreCache()
- * ```
- *
- * Reads a previously saved {@link Amity.Cache} from a persistent storage,
- * and inserts it into the current {@link Amity.Cache} instance.
- *
- * The strategy for persistent storage will depend on the runtime,
- * which is supported by @react-native-async-storage/async-storage.
- *
- * The current userId will be appended to the given storageKey to ensures
- * the cached data concerns only the current user.
- *
- * @param storageKey the name of the persistent storage
- * @returns a success boolean if the cache was dumped to persistent storage
- *
- * @category Cache API
+ * The current userId will be appended to the given storageKey to ensures
+ * the cached data concerns only the current user.
+ *
+ * @param storageKey the name of the persistent storage
+ * @returns a success boolean if the cache was dumped to persistent storage
+ *
+ * @category Cache API
  */
 const restoreCache = async (storageKey = 'amitySdk') => {
     var _a;
@@ -893,7 +796,6 @@ const restoreCache = async (storageKey = 'amitySdk') => {
     return true;
 };
 
-/* eslint-disable @typescript-eslint/no-unused-vars */
 /**
  * ```js
  * import { backupCache } from '@amityco/ts-sdk'
@@ -960,62 +862,6 @@ const wipeCache = async (storageKey = 'amitySdk') => {
     return true;
 };
 
-/**
- * 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]));
-};
-
 /**
  * ```js
  * import { queryCache } from '@amityco/ts-sdk'
@@ -1192,53 +1038,336 @@ const dropFromCache = (key, exact = false) => {
     return false;
 };
 
+// Note:
+// this file should contain a suite of filtering utilities to help the
+// local version of the query functions.
 /**
- * Creates a pre-configured logger instance
+ * Filter a given collection with strict equality against a param
  *
- * @param session The name of the debug session
- * @returns A pre-configured logger function
+ * @param collection the collection to filter
+ * @param key the key of the collection's items to challenge
+ * @param value the expected value
+ * @returns a filtered collection with items only matching the criteria
  *
- * @category Debug
  * @hidden
  */
-const createLogger = (session) => {
-    const active = `${session === null || session === void 0 ? void 0 : session.trim()}`.length > 0 && !isProduction;
-    const logger = debug(session);
-    const print = (topic, ...args) => {
-        active && logger(topic, args);
-    };
-    // eslint-disable-next-line no-underscore-dangle
-    print.__instance__ = logger;
-    return print;
-};
-
-const API_REGIONS = {
-    EU: 'eu',
-    SG: 'sg',
-    US: 'us',
-};
-const URLS = {
-    http: 'https://api.{region}.amity.co',
-    mqtt: 'wss://sse.{region}.amity.co:443/mqtt',
-};
-function computeUrl(type, region) {
-    return URLS[type].replace('{region}', region);
-}
-
+const filterByPropEquality = (collection, key, value) => (value !== undefined ? collection.filter(item => item[key] === value) : collection);
+const filterByPropInclusion = (collection, key, value) => (value !== undefined ? collection.filter(item => value.includes(item[key])) : collection);
 /**
- * Unwraps v3 server payload (for error handling and type extraction)
- *
- * @param response A typical "v3" response (related to backend's service strategy)
+ * Filter a channel collection by membership of the userId
  *
- * @returns The data returned by the backend
- * @throws An error related to backend's rejection
+ * @param collection the channel collection to filter
+ * @param membership the membership to be filtered by
+ * @param userId user id to be filtered by
+ * @returns a filtered collection with items only matching the criteria
  *
- * @category Transport
  * @hidden
  */
-const unwrapPayload = (response) => {
-    if (response.status === 'success') {
-        return response.data;
+const filterByChannelMembership = (collection, membership, userId) => {
+    if (membership === 'all') {
+        return collection;
+    }
+    return collection.filter(c => {
+        var _a;
+        // get resolver for the channel by user
+        const channelUserCacheKey = getResolver('channelUsers')({
+            channelId: c.channelId,
+            userId,
+        });
+        const channelUser = (_a = pullFromCache([
+            'channelUsers',
+            '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) {
+            return true;
+        }
+        return false;
+    });
+};
+
+// Note:
+// this file should contain a suite of sorting utilities to help the
+// local version of the query functions.
+/**
+ * Alphabetic sorting of objects having a displayName
+ */
+const sortByDisplayName = ({ displayName: a }, { displayName: b }) => {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+};
+/**
+ * Sorting a collection by their apparition order (oldest first)
+ */
+const sortByChannelSegment = ({ channelSegment: a }, { channelSegment: b }) => a - b;
+/**
+ * Sorting a collection by their apparition order (oldest first)
+ */
+const sortBySegmentNumber = ({ segmentNumber: a }, { segmentNumber: b }) => a - b;
+/**
+ * Sorting a collection by its oldest items
+ */
+const sortByFirstCreated = ({ createdAt: a }, { createdAt: b }) => new Date(a).valueOf() - new Date(b).valueOf();
+/**
+ * Sorting a collection by its newest items
+ */
+const sortByLastCreated = ({ createdAt: a }, { createdAt: b }) => new Date(b).valueOf() - new Date(a).valueOf();
+/**
+ * Sorting a collection by the items with most recent activity
+ */
+const sortByLastActivity = ({ lastActivity: a }, { lastActivity: b }) => new Date(b).valueOf() - new Date(a).valueOf();
+
+/* eslint-disable @typescript-eslint/ban-types */
+let tasks = [];
+let timer;
+/**
+ * Add a function to run just before the next tick
+ *
+ * @param task function to schedule for later execution
+ */
+const scheduleTask = (task) => {
+    clearTimeout(timer);
+    tasks.push(task);
+    timer = setTimeout(() => {
+        tasks.forEach(fn => fn());
+        tasks = [];
+    }, 0);
+};
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// need to sync up the list
+const WS_EVENTS = [
+    'disconnected',
+    'error',
+    'connect_error',
+    'reconnect_error',
+    'reconnect_failed',
+    'v3.channel.didCreate',
+    'v3.channel.didUpdate',
+    'v3.channel.didDelete',
+    'v3.channel.didMarkSeen',
+    'v3.channel.didJoin',
+    'v3.channel.didLeave',
+    'v3.channel.didAddUsers',
+    'v3.channel.didRemoveUsers',
+    'v3.channel.didBan',
+    'v3.channel.didUnban',
+    'v3.message.didFetch',
+    'v3.message.didCreate',
+    'v3.message.didUpdate',
+    'v3.message.didDelete',
+];
+const MQTT_EVENTS = [
+    'connect',
+    'message',
+    'disconnect',
+    'error',
+    'close',
+    'end',
+    'reconnect',
+];
+/** @hidden */
+const createEventEmitter = () => {
+    return mitt();
+};
+/**
+ * Wraps the websocket events into the client's event emitter for
+ * abstraction of transport.
+ *
+ * @param ws A websocket connection to listen from
+ * @param emitter An event emitter to wire the events to
+ *
+ * @category Transport
+ * @hidden
+ */
+const proxyWebsocketEvents = (ws, emitter) => {
+    WS_EVENTS.forEach(event => {
+        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));
+    });
+    // @ts-ignore
+    mqttClient.on('message', (topic, payload) => {
+        const message = JSON.parse(payload.toString());
+        emitter.emit(message.eventType, message.data);
+    });
+};
+/**
+ * Standardize the subscription of SSE through web sockets
+ *
+ * @param client The current client for which to subscribe the event to
+ * @param namespace A unique name for the logger
+ * @param event The websocket event name
+ * @param fn A wrapper for the callback.
+ * @returns A dispose function to unsubscribe to the event
+ *
+ * @category Transport
+ * @hidden
+ */
+const createEventSubscriber = (client, namespace, event, fn) => {
+    const { log, emitter } = client;
+    const timestamp = Date.now();
+    log(`${namespace}(tmpid: ${timestamp}) > listen`);
+    const handler = (...payload) => {
+        log(`${namespace}(tmpid: ${timestamp}) > trigger`, payload);
+        fn(...payload);
+    };
+    emitter.on(event, handler);
+    return () => {
+        log(`${namespace}(tmpid: ${timestamp}) > dispose`);
+        emitter.off(event, handler);
+    };
+};
+/**
+ * Wrapper around dispatch event
+ *
+ * @hidden
+ */
+const fireEvent = (event, payload) => {
+    const { emitter } = getActiveClient();
+    scheduleTask(() => {
+        emitter.emit(event, payload);
+    });
+};
+
+let activeUser = null;
+/**
+ * for internal use
+ */
+const getActiveUser = () => {
+    if (!activeUser) {
+        throw new ASCError('Connect client first', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "fatal" /* Amity.ErrorLevel.FATAL */);
+    }
+    return activeUser;
+};
+const setActiveUser = (user) => {
+    activeUser = {
+        _id: user._id,
+        userId: user.userId,
+        path: user.path,
+    };
+};
+
+var SubscriptionLevels;
+(function (SubscriptionLevels) {
+    SubscriptionLevels["COMMUNITY"] = "community";
+    SubscriptionLevels["POST"] = "post";
+    SubscriptionLevels["COMMENT"] = "comment";
+    SubscriptionLevels["POST_AND_COMMENT"] = "post_and_comment";
+    SubscriptionLevels["USER"] = "user";
+})(SubscriptionLevels || (SubscriptionLevels = {}));
+const getCommunityUserTopic = (path, level) => {
+    switch (level) {
+        case 'post':
+            return `${path}/post/+`;
+        case 'comment':
+            return `${path}/post/+/comment/+`;
+        case 'post_and_comment':
+            return `${path}/post/#`;
+        default:
+            return path;
+    }
+};
+const getCommunityTopic = ({ path }, level = SubscriptionLevels.COMMUNITY) => getCommunityUserTopic(path, level);
+const getUserTopic = ({ path }, level = SubscriptionLevels.USER) => getCommunityUserTopic(level === SubscriptionLevels.USER ? path : path.replace(/^(\w*)/, '$1/social'), level);
+const getPostTopic = ({ path }, level = SubscriptionLevels.POST) => {
+    switch (level) {
+        case 'comment':
+            return `${path}/comment/+`;
+        default:
+            return path;
+    }
+};
+const getCommentTopic = ({ path }) => {
+    return path;
+};
+const getMyFollowersTopic = () => {
+    const user = getActiveUser();
+    const [networkId] = user.path.split('/user/');
+    return `${networkId}/membership/${user._id}/+/+`;
+};
+const getMyFollowingsTopic = () => {
+    const user = getActiveUser();
+    const [networkId] = user.path.split('/user/');
+    return `${networkId}/membership/+/${user._id}/+`;
+};
+/** @hidden */
+const getNetworkTopic = () => {
+    const user = getActiveUser();
+    const [networkId] = user.path.split('/user/');
+    return networkId;
+};
+let mqttAccessToken;
+let mqttUserId;
+function subscribeTopic(topic, callback) {
+    const { mqtt, emitter, accessToken } = getActiveClient();
+    const user = getActiveUser();
+    if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
+        mqttAccessToken = accessToken;
+        mqttUserId = user._id;
+        mqtt.connect({ accessToken: mqttAccessToken, userId: mqttUserId });
+        proxyMqttEvents(mqtt, emitter);
+    }
+    return mqtt.subscribe(topic, callback);
+}
+
+/**
+ * Creates a pre-configured logger instance
+ *
+ * @param session The name of the debug session
+ * @returns A pre-configured logger function
+ *
+ * @category Debug
+ * @hidden
+ */
+const createLogger = (session) => {
+    const active = `${session === null || session === void 0 ? void 0 : session.trim()}`.length > 0 && !isProduction;
+    const logger = debug(session);
+    const print = (topic, ...args) => {
+        active && logger(topic, args);
+    };
+    // eslint-disable-next-line no-underscore-dangle
+    print.__instance__ = logger;
+    return print;
+};
+
+const API_REGIONS = {
+    EU: 'eu',
+    SG: 'sg',
+    US: 'us',
+};
+const URLS = {
+    http: 'https://api.{region}.amity.co',
+    mqtt: 'wss://sse.{region}.amity.co:443/mqtt',
+};
+function computeUrl(type, region) {
+    return URLS[type].replace('{region}', region);
+}
+
+/**
+ * Unwraps v3 server payload (for error handling and type extraction)
+ *
+ * @param response A typical "v3" response (related to backend's service strategy)
+ *
+ * @returns The data returned by the backend
+ * @throws An error related to backend's rejection
+ *
+ * @category Transport
+ * @hidden
+ */
+const unwrapPayload = (response) => {
+    if (response.status === 'success') {
+        return response.data;
     }
     if (response.status === 'fail') {
         throw new ASCUnknownError(response.code);
@@ -1254,21 +1383,8 @@ const unwrapPayload = (response) => {
  * Axios param serializer (for querystring)
  * @hidden
  */
-const stringify = (params, prefix) => {
-    return Object.entries(params)
-        .filter(([, value]) => value !== undefined)
-        .map(([name, value]) => {
-        const key = prefix ? `${prefix}[${name}]` : name;
-        if (Array.isArray(value)) {
-            return value.map(item => `${key}[]=${item}`).join('&');
-        }
-        if (typeof value !== 'object') {
-            return `${key}=${value}`;
-        }
-        // @ts-ignore
-        return stringify(value, prefix !== null && prefix !== void 0 ? prefix : name);
-    })
-        .join('&');
+const stringify = (params) => {
+    return qs.stringify(params, { arrayFormat: 'brackets' });
 };
 /**
  * Creates a pre-configured axios instance
@@ -20141,6 +20257,28 @@ const createMqttTransport = (endpoint) => {
     };
 };
 
+/**
+ * ```js
+ * import { getFeedSettings } from '@amityco/ts-sdk'
+ * const feedSettings = await getFeedSettings()
+ * const postFeedSetting = feedSettings.post
+ * ```
+ *
+ * Fetches a {@link Amity.FeedSettings} object
+ *
+ * @returns A Promise of {@link Amity.FeedSettings} object
+ *
+ * @category Client API
+ * @async
+ */
+const getFeedSettings = async () => {
+    const client = getActiveClient();
+    const { data } = await client.http.get(`/api/v3/network-settings/feed-setting`);
+    return Object.fromEntries(data.feedSettings.map(({ feedType, contentSettings }) => {
+        return [feedType, contentSettings];
+    }));
+};
+
 const DEFAULT_DEBUG_SESSION = 'amity';
 /**
  * ```js
@@ -20180,6 +20318,7 @@ const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAU
         mqtt,
         emitter,
         use: () => setActiveClient(client),
+        getFeedSettings,
     };
     try {
         getActiveClient();
@@ -20257,7 +20396,7 @@ const getDeviceInfo = () => {
  * Ingest a payload (v3) into the cache
  *
  * @param payload a "backend v3" payload object
- * @param order the order of the keys to process (in case of need)
+ * @param options caching options like cachedAt or offline
  *
  * @category Cache
  * @hidden
@@ -20269,9 +20408,7 @@ const ingestInCache = (payload = {}, options) => {
             return;
         const resolver = getResolver(type);
         models.forEach(model => {
-            upsertInCache(
-            // eslint-disable @typescript-eslint no-explicit-any
-            [type, 'get', resolver(model)], // this 'any' cannot be avoided, sorry.
+            upsertInCache([type, 'get', resolver(model)], // this 'any' cannot be avoided, sorry.
             model, options);
         });
     });
@@ -20421,7 +20558,6 @@ const onClientBanned = (callback) => {
  * @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
- * @param config
  * @returns a success boolean if connected
  *
  * @category Client API
@@ -20482,10 +20618,65 @@ const isConnected = () => {
     const client = getActiveClient();
     client.log('client/api/isConnected', client);
     return !!(client.userId &&
-        ((_b = (_a = client.http.defaults.headers.common) === null || _a === void 0 ? void 0 : _a.Authorization) === null || _b === void 0 ? void 0 : _b.length) &&
+        ((_b = String((_a = client.http.defaults.headers.common) === null || _a === void 0 ? void 0 : _a.Authorization)) === null || _b === void 0 ? void 0 : _b.length) &&
         client.ws.connected);
 };
 
+/**
+ * ```js
+ * import { isInTombstone } from '@amityco/ts-sdk'
+ * const user = isInTombstone(["message", "messageId"])
+ * ```
+ *
+ * Checks if the {@link Amity.TombstoneCacheOptions} exists
+ * in cache and it's not expired means it's in tombstone
+ * and we throw an Error
+ *
+ * @param model the model to check
+ * @param modelId the object id to check
+ * @returns the matching cache entry, or undefined.
+ *
+ * @category Cache API
+ */
+const isInTombstone = (model, modelId) => {
+    const { log, cache } = getActiveClient();
+    const key = [model, CACHE_KEY_TOMBSTONE, modelId];
+    if (!cache)
+        return;
+    log('cache/api/isInTombstone', key);
+    const isInTombstone = pullFromCache(key);
+    const { lifeSpan } = queryOptions('cache_then_server', CACHE_LIFESPAN_TOMBSTONE);
+    if (isInTombstone && isFresh(isInTombstone.data, lifeSpan)) {
+        throw new ASCApiError('Item not found!', 400400 /* Amity.ServerError.ITEM_NOT_FOUND */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+};
+
+/**
+ * ```js
+ * import { pushToTombstone } from '@amityco/ts-sdk'
+ * pushToTombstone(["message", "messageId"], { cachedAt: Date.now() })
+ * ```
+ *
+ * Removes an existing {@link Amity.CacheEntry} from the {@link Amity.Client}'s
+ * {@link Amity.Cache} from a given {@link Amity.CacheKey}
+ *
+ * @param model the model to remove and push to Tombstone
+ * @param modelId the related model id
+ *
+ * @category Cache API
+ * @hidden
+ */
+const pushToTombstone = (model, modelId) => {
+    const { log, cache } = getActiveClient();
+    const cacheKey = [model, CACHE_KEY_TOMBSTONE, modelId];
+    const data = { cachedAt: Date.now() };
+    if (!cache)
+        return;
+    log('cache/api/pushToTombstone', { cacheKey, data });
+    dropFromCache([model, CACHE_KEY_GET, modelId], true);
+    pushToCache(cacheKey, data);
+};
+
 /**
  * ```js
  * import { getUser } from '@amityco/ts-sdk'
@@ -20500,15 +20691,29 @@ const isConnected = () => {
  * @category User API
  * @async
  */
-const getUser = async (userId) => {
+const getUser = async (userId, isLive = false) => {
     const client = getActiveClient();
     client.log('user/getUser', userId);
-    // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const { data } = await client.http.get(`/api/v3/users/${encodeURIComponent(userId)}`);
+    if (!isLive) {
+        console.log('getUser will be deprecated on 25th November 2022, please use liveUser instead.');
+    }
+    isInTombstone('user', userId);
+    let data;
+    try {
+        const response = await client.http.get(`/api/v3/users/${encodeURIComponent(userId)}`);
+        data = response.data;
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('user', userId);
+        }
+        throw error;
+    }
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
     const { users } = data;
+    fireEvent('user.fetched', data);
     return {
         data: users.find(user => user.userId === userId),
         cachedAt,
@@ -20558,6 +20763,7 @@ const getUsers = async (userIds) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
+    fireEvent('user.fetched', data);
     return {
         data: data.users,
         cachedAt,
@@ -20640,8 +20846,7 @@ function __rest(s, e) {
 const queryUsers = async (query = {}) => {
     const client = getActiveClient();
     client.log('user/queryUsers', query);
-    const { page, displayName, filter = 'all', sortBy = 'displayName' } = query, params = __rest(query, ["page", "displayName", "filter", "sortBy"]);
-    // API-FIX: parameters should be querystring.
+    const { page = { limit: 10 }, displayName, filter = 'all', sortBy = 'displayName' } = query, params = __rest(query, ["page", "displayName", "filter", "sortBy"]);
     const { data } = await client.http.get(`/api/v3/users`, {
         params: Object.assign(Object.assign({}, params), { keyword: displayName, filter,
             sortBy, options: {
@@ -20654,9 +20859,14 @@ const queryUsers = async (query = {}) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
         ingestInCache(payload, { cachedAt });
-        const cacheKey = ['user', 'query', query];
+        /*
+         * using query as cache key over params because if the keyword, filter, sort
+         * change the API will NOT cache results, when it should
+         */
+        const cacheKey = ['user', 'query', Object.assign(Object.assign({}, query), { options: Object.assign({}, page) })];
         pushToCache(cacheKey, { users: users.map(getResolver('user')), paging });
     }
+    fireEvent('user.fetched', data);
     const prevPage = toPage(paging.previous);
     const nextPage = toPage(paging.next);
     return { data: users, cachedAt, prevPage, nextPage };
@@ -20681,8 +20891,13 @@ queryUsers.locally = (query = {}) => {
     client.log('user/queryUsers.locally', query);
     if (!client.cache)
         return;
-    const queryKey = ['user', 'query', query];
-    const { data, cachedAt } = (_a = pullFromCache(queryKey)) !== null && _a !== void 0 ? _a : {};
+    const { page = { limit: 10 } } = query !== null && query !== void 0 ? query : {};
+    const cacheKey = [
+        'user',
+        'query',
+        Object.assign(Object.assign({}, query), { options: Object.assign({}, page) }),
+    ];
+    const { data, cachedAt } = (_a = pullFromCache(cacheKey)) !== null && _a !== void 0 ? _a : {};
     const users = (_b = data === null || data === void 0 ? void 0 : data.users.map(userId => pullFromCache(['user', 'get', userId])).filter(Boolean).map(({ data }) => data)) !== null && _b !== void 0 ? _b : [];
     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);
@@ -20720,12 +20935,30 @@ const updateUser = async (userId, patch) => {
     if (client.cache)
         ingestInCache(data, { cachedAt });
     const { users } = data;
+    fireEvent('user.updated', data);
     return {
         data: users.find(user => user.userId === userId),
         cachedAt,
     };
 };
 
+/**
+ * ```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'
@@ -20794,6 +21027,68 @@ 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 { liveUser } from '@amityco/ts-sdk'
+ *
+ * let users = []
+ * const unsub = liveUser(userId, response => merge(users, 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
+ *
+ * @category Message Live Object
+ */
+const liveUser = (userId, callback) => {
+    const { log, cache } = getActiveClient();
+    let user;
+    if (!cache) {
+        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveUser(tmpid: ${timestamp}) > listen`);
+    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;
+    };
+    const realtimeRouter = (user, action) => {
+        dispatcher({ loading: false, data: user, 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)));
+    onFetch();
+    return () => {
+        log(`liveUser(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 /**
  * ```js
  * import { observeUser } from '@amityco/ts-sdk'
@@ -20813,6 +21108,7 @@ const observeUser = (userId, callback) => {
     const { log } = getActiveClient();
     const timestamp = Date.now();
     log(`observeUser(tmpid: ${timestamp}) > listen`);
+    console.log('observeUser will be deprecated on 25th November 2022, please use liveUser instead.');
     // wrapper function to make sure
     const router = (result, action) => {
         var _a, _b, _c;
@@ -20973,17 +21269,21 @@ const fileUrlWithSize = (fileUrl, size) => {
  * Creates an {@link Amity.File<'video'>}
  *
  * @param formData The data necessary to create a new {@link Amity.File<'video'>}
+ * @param feedType The {@link Amity.File<'video'>} feed type
  * @param onProgress The callback to track the upload progress
  * @returns The newly created {@link Amity.File<'video'>}
  *
  * @category File API
  * @async
  */
-const createVideo = async (formData, onProgress) => {
+const createVideo = async (formData, feedType, onProgress) => {
     const client = getActiveClient();
     client.log('file/createVideo', formData);
     if (!formData.getAll('files').length)
         throw new Error('The formData object must have a `files` key.');
+    if (feedType) {
+        formData.append('feedType', feedType);
+    }
     const headers = 'getHeaders' in formData
         ? formData.getHeaders()
         : { 'content-type': 'multipart/form-data' };
@@ -21218,15 +21518,30 @@ const dispatchReactable = (referenceType, model) => {
  * @category Message API
  * @async
  */
-const getMessage = async (messageId) => {
+const getMessage = async (messageId, isLive = false) => {
     const client = getActiveClient();
     client.log('message/getMessage', messageId);
-    // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const { data } = await client.http.get(`/api/v3/messages/${encodeURIComponent(messageId)}`);
+    if (!isLive) {
+        console.log('getMessage will be deprecated on 15th November 2022, please use liveMessage instead.');
+    }
+    isInTombstone('message', messageId);
+    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)}`);
+        data = response.data;
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('message', messageId);
+        }
+        throw error;
+    }
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
     const { messages } = data;
+    fireEvent('v3.message.didFetch', { messages });
     return {
         data: messages.find(message => message.messageId === messageId),
         cachedAt,
@@ -21283,8 +21598,10 @@ const getMessages = async (messageIds) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
+    const { messages } = data;
+    fireEvent('v3.message.didFetch', { messages });
     return {
-        data: data.messages,
+        data: messages,
         cachedAt,
     };
 };
@@ -21361,6 +21678,7 @@ const queryMessages = async (query) => {
         ];
         pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });
     }
+    fireEvent('v3.message.didFetch', { messages });
     const nextPage = toPage(paging.next);
     const prevPage = toPage(paging.previous);
     return { data: messages, cachedAt, prevPage, nextPage };
@@ -21426,8 +21744,8 @@ const createMessage = async (bundle) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
-    // no need for event, fired by server
     const { messages } = data;
+    fireEvent('v3.message.didCreate', { messages });
     return {
         data: messages[0],
         cachedAt,
@@ -21469,11 +21787,12 @@ createMessage.optimistically = (bundle) => {
     // 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);
-    pushToCache(['message', 'get', message.messageId], message, { cachedAt: -1 });
+    const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
+    pushToCache(['message', 'get', message.messageId], message, { cachedAt });
     fireEvent('v3.message.didCreate', { messages: [message] });
     return {
+        cachedAt,
         data: message,
-        cachedAt: -1,
     };
 };
 
@@ -21502,6 +21821,7 @@ const updateMessage = async (messageId, patch) => {
     if (client.cache)
         ingestInCache(data, { cachedAt });
     const { messages } = data;
+    fireEvent('v3.message.didUpdate', { messages });
     return {
         data: messages.find(message => message.messageId === messageId),
         cachedAt,
@@ -21561,7 +21881,7 @@ const deleteMessage = async (messageId) => {
     // API-FIX: This endpoint has not been implemented yet.
     await client.http.delete(`/api/v3/messages/${encodeURIComponent(messageId)}`);
     const deleted = await getMessage(messageId);
-    // no need for event, fired by server
+    fireEvent('v3.message.didDelete', { messages: [deleted.data] });
     return deleted.data;
 };
 /**
@@ -21611,11 +21931,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'),
             } }),
     });
@@ -21748,6 +22077,7 @@ getPosts.locally = (postIds) => {
 const getPost = async (postId) => {
     const client = getActiveClient();
     client.log('post/getPost', postId);
+    isInTombstone('post', postId);
     let data;
     try {
         // API-FIX: endpoint should not be /list, parameters should be querystring.
@@ -21755,8 +22085,8 @@ const getPost = async (postId) => {
         data = response.data;
     }
     catch (error) {
-        if ((error === null || error === void 0 ? void 0 : error.code) === 400400 /* Amity.ServerError.ITEM_NOT_FOUND */) {
-            dropFromCache(['post', 'get', postId], true);
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('post', postId);
         }
         throw error;
     }
@@ -21866,6 +22196,33 @@ const updatePost = async (postId, patch) => {
     };
 };
 
+const getMatchPostSetting = (value) => {
+    var _a;
+    return (_a = Object.keys(CommunityPostSettingMaps).find(key => value.needApprovalOnPostCreation ===
+        CommunityPostSettingMaps[key].needApprovalOnPostCreation &&
+        value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost)) !== null && _a !== void 0 ? _a : DefaultCommunityPostSetting;
+};
+/*
+ * Unpack community payload by mapping payload field to postSetting value.
+ */
+const unpackCommunityPayload = (_a) => {
+    var { communities } = _a, restPayload = __rest(_a, ["communities"]);
+    return (Object.assign({ communities: communities.map((_a) => {
+            var { needApprovalOnPostCreation, onlyAdminCanPost } = _a, restCommunityPayload = __rest(_a, ["needApprovalOnPostCreation", "onlyAdminCanPost"]);
+            return (Object.assign({ postSetting: getMatchPostSetting({
+                    needApprovalOnPostCreation,
+                    onlyAdminCanPost,
+                }) }, restCommunityPayload));
+        }) }, restPayload));
+};
+/*
+ * Repack community payload by mapping postSetting to the actual value.
+ */
+const packCommunityPayload = (_a) => {
+    var { postSetting = undefined } = _a, restParam = __rest(_a, ["postSetting"]);
+    return (Object.assign(Object.assign({}, restParam), (postSetting ? CommunityPostSettingMaps[postSetting] : undefined)));
+};
+
 /**
  * ```js
  * import { queryCommunities } from '@amityco/ts-sdk'
@@ -21895,10 +22252,11 @@ const queryCommunities = async (query) => {
             } }),
     });
     const { paging } = data, payload = __rest(data, ["paging"]);
-    const { communities } = payload;
+    const unpackedPayload = unpackCommunityPayload(payload);
+    const { communities } = unpackedPayload;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
-        ingestInCache(payload, { cachedAt });
+        ingestInCache(unpackedPayload, { cachedAt });
         const cacheKey = [
             'community',
             'query',
@@ -21947,9 +22305,10 @@ const getCommunities = async (communityIds) => {
     const client = getActiveClient();
     client.log('community/getCommunities', communityIds);
     // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const { data } = await client.http.get(`/api/v3/communities/list`, {
+    const { data: payload } = await client.http.get(`/api/v3/communities/list`, {
         params: { communityIds },
     });
+    const data = unpackCommunityPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -22008,7 +22367,8 @@ const getCommunity = async (communityId) => {
     const client = getActiveClient();
     client.log('community/getCommunity', communityId);
     // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const { data } = await client.http.get(`/api/v3/communities/${communityId}`);
+    const { data: payload } = await client.http.get(`/api/v3/communities/${communityId}`);
+    const data = unpackCommunityPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -22062,7 +22422,8 @@ getCommunity.locally = (communityId) => {
 const createCommunity = async (bundle) => {
     const client = getActiveClient();
     client.log('user/createCommunity', bundle);
-    const { data } = await client.http.post('/api/v3/communities/', bundle);
+    const { data: payload } = await client.http.post('/api/v3/communities/', packCommunityPayload(bundle));
+    const data = unpackCommunityPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -22092,7 +22453,8 @@ const createCommunity = async (bundle) => {
 const updateCommunity = async (communityId, patch) => {
     const client = getActiveClient();
     client.log('community/updateCommunity', communityId, patch);
-    const { data } = await client.http.put(`/api/v3/communities/${communityId}`, patch);
+    const { data: payload } = await client.http.put(`/api/v3/communities/${communityId}`, packCommunityPayload(patch));
+    const data = unpackCommunityPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -22180,6 +22542,58 @@ const leaveCommunity = async (communityId) => {
     return !!communityUsers.find(communityUser => communityUser.communityId === communityId && communityUser.communityMembership !== 'member');
 };
 
+/**
+ * Attach user object to membership model
+ * - If cache is not enabled, set user to undefined ({..., user: undefined})
+ * - If user object is not found in cache, set user to undefined
+ * ({..., user: undefined})
+ * - If a user is found in the cache, it attaches the user from the cache
+ * ({..., user: { userId, displayName,... }})
+ *
+ * @param member The membership model object
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The membership model object that is already mapped to user
+ * @hidden
+ */
+const withUser = (member, userIdProp = 'userId', userProp = 'user') => (Object.assign({ get [userProp]() {
+        var _a;
+        const client = getActiveClient();
+        if (!client.cache)
+            return undefined;
+        const userCache = (_a = pullFromCache(['user', 'get', member[userIdProp]])) === null || _a === void 0 ? void 0 : _a.data;
+        if (!userCache) {
+            return undefined;
+        }
+        return userCache;
+    } }, member));
+/**
+ * Mapping membership model with user object
+ *
+ * @param members The membership model objects
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The membership model objects that is already
+ * mapped to users
+ * @hidden
+ */
+const withUsers = (members, userIdProp = 'userId', userProp = 'user') => members.map(member => withUser(member, userIdProp, userProp));
+/**
+ * Transform members prop in any payload with attached users members
+ *
+ * @param payload The payload contain members prop
+ * @param memberProp A name of members prop
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The transforming payload
+ * @hidden
+ */
+const prepareMembershipPayload = (payload, memberProp, userIdProp = 'userId', userProp = 'user') => {
+    const _a = payload, _b = memberProp, memberPayload = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+    const members = withUsers(memberPayload, userIdProp, userProp);
+    return Object.assign(Object.assign({}, rest), { [memberProp]: members });
+};
+
 /**
  * ```js
  * import { queryCommunityMembers } from '@amityco/ts-sdk'
@@ -22197,17 +22611,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);
@@ -22227,9 +22651,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;
 };
 
 /**
@@ -22358,7 +22802,8 @@ const getTopTrendingCommunities = async (query) => {
     const { limit = 5 } = query !== null && query !== void 0 ? query : {};
     // API-FIX: backend doesnt answer Amity.Response
     // const { data } = await client.http.get<Amity.Response<CommunityPayload>>(
-    const { data } = await client.http.get(`/api/v3/communities/top-trending`, { params: { options: { limit } } });
+    const { data: payload } = await client.http.get(`/api/v3/communities/top-trending`, { params: { options: { limit } } });
+    const data = unpackCommunityPayload(payload);
     const { communities } = data;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
@@ -22420,8 +22865,9 @@ const getRecommendedCommunities = async (query) => {
     client.log('channel/getRecommendedCommunities', query);
     const { limit = 5 } = query !== null && query !== void 0 ? query : {};
     // API-FIX: backend doesnt answer Amity.Response
-    // const { data } = await client.http.get<Amity.Response<CommunityPayload>>(
-    const { data } = await client.http.get(`/api/v3/communities/recommended`, { params: { options: { limit } } });
+    // const { data: payload } = await client.http.get<Amity.Response<CommunityPayload>>(
+    const { data: payload } = await client.http.get(`/api/v3/communities/recommended`, { params: { options: { limit } } });
+    const data = unpackCommunityPayload(payload);
     const { communities } = data;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
@@ -22502,7 +22948,7 @@ const deletePost = async (postId, permanent = false) => {
     fireEvent('post.deleted', { posts: [deleted] });
     if (permanent) {
         setTimeout(() => {
-            dropFromCache(['post', 'get', postId], true);
+            pushToTombstone('post', postId);
         }, 0);
     }
     else {
@@ -22898,17 +23344,6 @@ const deleteComment = async (commentId, permanent = false) => {
     return deleted;
 };
 
-/** @hidden */
-const fetchReference = async (referenceType, referenceId) => {
-    if (referenceType === 'message')
-        return getMessage(referenceId);
-    if (referenceType === 'post')
-        return getPost(referenceId);
-    if (referenceType === 'comment')
-        return getComment(referenceId);
-    throw new Error(`Incorrect referenceType: ${referenceType}`);
-};
-
 /** @hidden */
 const preparePayloadForCache = (event, payload) => {
     var _a, _b;
@@ -22996,7 +23431,6 @@ const prepareMessagePayloadForCache = (payload) => {
  * @async
  * */
 const addReaction = async (referenceType, referenceId, reactionName) => {
-    var _a, _b;
     const client = getActiveClient();
     client.log('reaction/createReaction', {
         referenceId,
@@ -23008,9 +23442,16 @@ const addReaction = async (referenceType, referenceId, reactionName) => {
         referenceType,
         reactionName,
     });
-    const model = await fetchReference(referenceType, referenceId);
-    dispatchReactable(referenceType, model.data);
-    return (_b = (_a = model.data.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName)) !== null && _b !== void 0 ? _b : false;
+    if (client.cache) {
+        const model = pullFromCache([
+            referenceType,
+            'get',
+            referenceId,
+        ]);
+        (model === null || model === void 0 ? void 0 : model.data) &&
+            pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+    }
+    return true;
 };
 /**
  * ```js
@@ -23045,7 +23486,9 @@ addReaction.optimistically = (referenceType, referenceId, reactionName) => {
     if (!(model === null || model === void 0 ? void 0 : model.data) || ((_a = model.data.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName)))
         return;
     const reaction = Object.assign(Object.assign({}, model.data), { reactionsCount: model.data.reactionsCount + 1, myReactions: [...((_b = model.data.myReactions) !== null && _b !== void 0 ? _b : []), reactionName], reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: ((_c = model.data.reactions[reactionName]) !== null && _c !== void 0 ? _c : 0) + 1 }) });
-    upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
+    upsertInCache([referenceType, 'get', referenceId], reaction, {
+        cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+    });
     dispatchReactable(referenceType, reaction);
     return (_e = (_d = reaction === null || reaction === void 0 ? void 0 : reaction.myReactions) === null || _d === void 0 ? void 0 : _d.includes(reactionName)) !== null && _e !== void 0 ? _e : false;
 };
@@ -23067,7 +23510,6 @@ addReaction.optimistically = (referenceType, referenceId, reactionName) => {
  * @async
  * */
 const removeReaction = async (referenceType, referenceId, reactionName) => {
-    var _a, _b;
     const client = getActiveClient();
     client.log('reaction/removeReaction', {
         referenceId,
@@ -23077,9 +23519,16 @@ const removeReaction = async (referenceType, referenceId, reactionName) => {
     await client.http.delete(`/api/v2/reactions`, {
         data: { referenceId, referenceType, reactionName },
     });
-    const model = await fetchReference(referenceType, referenceId);
-    dispatchReactable(referenceType, model.data);
-    return (_b = !((_a = model.data.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName))) !== null && _b !== void 0 ? _b : false;
+    if (client.cache) {
+        const model = pullFromCache([
+            referenceType,
+            'get',
+            referenceId,
+        ]);
+        (model === null || model === void 0 ? void 0 : model.data) &&
+            pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+    }
+    return true;
 };
 /**
  * ```js
@@ -23114,7 +23563,9 @@ removeReaction.optimistically = (referenceType, referenceId, reactionName) => {
     if (!(model === null || model === void 0 ? void 0 : model.data) || !((_a = model.data.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName)))
         return;
     const reaction = Object.assign(Object.assign({}, model.data), { reactionsCount: Math.max(0, model.data.reactionsCount - 1), myReactions: ((_b = model.data.myReactions) !== null && _b !== void 0 ? _b : []).filter(item => item !== reactionName), reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: Math.max(0, ((_c = model.data.reactions[reactionName]) !== null && _c !== void 0 ? _c : 0) - 1) }) });
-    upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
+    upsertInCache([referenceType, 'get', referenceId], reaction, {
+        cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+    });
     dispatchReactable(referenceType, reaction);
     return (_e = !((_d = reaction === null || reaction === void 0 ? void 0 : reaction.myReactions) === null || _d === void 0 ? void 0 : _d.includes(reactionName))) !== null && _e !== void 0 ? _e : false;
 };
@@ -23756,9 +24207,6 @@ const onReactorRemoved = (referenceType, referenceId, callback) => {
     return createEventSubscriber(client, 'comment.removeReaction', 'comment.removeReaction', filter);
 };
 
-const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
-const COLLECTION_DEFAULT_CACHING_POLICY = 'cache_then_server';
-
 /**
  * ```js
  * import { liveReactions } from '@amityco/ts-sdk'
@@ -23959,6 +24407,23 @@ const isReportedByMe = async (referenceType, referenceId) => {
     return (_b = result !== null && result !== void 0 ? result : isFlagByMe) !== null && _b !== void 0 ? _b : false;
 };
 
+/** @hidden */
+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 });
+    });
+    return Object.assign(Object.assign({}, payload), { channels });
+};
+
 /**
  * ```js
  * import { queryChannels } from '@amityco/ts-sdk'
@@ -23982,16 +24447,17 @@ const queryChannels = async (query) => {
     // API-FIX: parameters should be querystring.
     // API-FIX: backend doesnt answer Amity.Response
     // const { data } = await client.http.get<Amity.Response<Amity.Paged<ChannelPayload>>>(
-    const { data } = await client.http.get(`/api/v3/channels`, {
+    const { data: queryPayload } = await client.http.get(`/api/v3/channels`, {
         params: Object.assign(Object.assign({}, params), { keyword: displayName, filter: membership, options: {
                 token: toToken(page, 'skiplimit'),
             } }),
     });
-    const { paging } = data, payload = __rest(data, ["paging"]);
-    const { channels } = payload;
+    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
+    const data = prepareChannelPayload(payload);
+    const { channels } = data;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
-        ingestInCache(payload, { cachedAt });
+        ingestInCache(data, { cachedAt });
         const cacheKey = [
             'channel',
             'query',
@@ -24017,9 +24483,24 @@ const queryChannels = async (query) => {
  * @category Channel API
  */
 queryChannels.locally = (query) => {
+    var _a, _b;
     const client = getActiveClient();
     client.log('channel/queryChannels.locally', query);
-    // TODO
+    const _c = query !== null && query !== void 0 ? query : {}, { page = { limit: 10 } } = _c, params = __rest(_c, ["page"]);
+    const cacheKey = ['channel', '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.channels.length))
+        return;
+    const channels = data.channels
+        // ck -> cacheKey, abbrevated to avoid confusion from the above cache key
+        .map(ck => pullFromCache(['channel', '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 channels.length === ((_b = data === null || data === void 0 ? void 0 : data.channels) === null || _b === void 0 ? void 0 : _b.length)
+        ? { data: channels, cachedAt, prevPage, nextPage }
+        : undefined;
 };
 
 /**
@@ -24041,9 +24522,10 @@ const getChannels = async (channelIds) => {
     client.log('channel/getChannels', channelIds);
     const encodedChannelIds = channelIds.map(channelId => encodeURIComponent(channelId));
     // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const { data } = await client.http.get(`/api/v3/channels/list`, {
+    const { data: payload } = await client.http.get(`/api/v3/channels/list`, {
         params: { channelIds: encodedChannelIds },
     });
+    const data = prepareChannelPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -24101,8 +24583,18 @@ getChannels.locally = (channelIds) => {
 const getChannel = async (channelId) => {
     const client = getActiveClient();
     client.log('channel/getChannel', channelId);
-    // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const { data } = await client.http.get(`/api/v3/channels/${encodeURIComponent(channelId)}`);
+    isInTombstone('channel', channelId);
+    let data;
+    try {
+        const { data: payload } = await client.http.get(`/api/v3/channels/${encodeURIComponent(channelId)}`);
+        data = prepareChannelPayload(payload);
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('channel', channelId);
+        }
+        throw error;
+    }
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -24163,10 +24655,11 @@ const createChannel = async (bundle) => {
     else {
         payload = await client.http.post('/api/v3/channels', bundle);
     }
+    const data = prepareChannelPayload(payload.data);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(payload.data, { cachedAt });
-    const { channels } = payload.data;
+        ingestInCache(data, { cachedAt });
+    const { channels } = data;
     return {
         data: channels[0],
         cachedAt,
@@ -24191,7 +24684,8 @@ const createChannel = async (bundle) => {
 const updateChannel = async (channelId, patch) => {
     const client = getActiveClient();
     client.log('channel/updateChannel', channelId, patch);
-    const { data } = await client.http.put(`/api/v3/channels/${encodeURIComponent(channelId)}`, patch);
+    const { data: payload } = await client.http.put(`/api/v3/channels/${encodeURIComponent(channelId)}`, patch);
+    const data = prepareChannelPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -24242,7 +24736,8 @@ const deleteChannel = async (channelId) => {
 const joinChannel = async (channelId) => {
     const client = getActiveClient();
     client.log('channel/joinChannel', channelId);
-    const { data } = await client.http.post(`/api/v3/channels/${encodeURIComponent(channelId)}/join`);
+    const { data: payload } = await client.http.post(`/api/v3/channels/${encodeURIComponent(channelId)}/join`);
+    const data = prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
     const { channelUsers } = data;
@@ -24266,7 +24761,8 @@ const joinChannel = async (channelId) => {
 const leaveChannel = async (channelId) => {
     const client = getActiveClient();
     client.log('channel/leaveChannel', channelId);
-    const { data } = await client.http.delete(`/api/v3/channels/${encodeURIComponent(channelId)}/leave`);
+    const { data: payload } = await client.http.delete(`/api/v3/channels/${encodeURIComponent(channelId)}/leave`);
+    const data = prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
     const { channelUsers } = data;
@@ -24290,21 +24786,37 @@ 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, channelId } = _a, params = __rest(_a, ["page", "channelId"]);
-    const { data } = await client.http.get(`/api/v4/channels/${encodeURIComponent(channelId)}/users`, {
+    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 } = data, payload = __rest(data, ["paging"]);
-    const { channelUsers } = payload;
+    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channelUsers } = preparedPayload;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
-        ingestInCache(payload);
+        ingestInCache(preparedPayload);
+        const cacheKey = [
+            'channelUsers',
+            'query',
+            Object.assign(Object.assign({}, params), { options: Object.assign({}, page) }),
+        ];
+        pushToCache(cacheKey, {
+            channelUsers: channelUsers.map(({ channelId, userId }) => getResolver('channelUsers')({ channelId, userId })),
+            paging,
+        });
     }
     const nextPage = toPage(paging.next);
     const prevPage = toPage(paging.previous);
-    return { data: channelUsers, cachedAt, nextPage, prevPage };
+    return {
+        data: channelUsers,
+        cachedAt,
+        nextPage,
+        prevPage,
+    };
 };
 /**
  * ```js
@@ -24320,9 +24832,30 @@ const queryChannelMembers = async (query) => {
  * @category Post API
  */
 queryChannelMembers.locally = (query) => {
+    var _a, _b;
     const client = getActiveClient();
-    client.log('channel/queryChannelMembers', query);
-    // TODO
+    client.log('channel/queryChannelMembers.locally', query);
+    if (!client.cache)
+        return;
+    const { page } = query, params = __rest(query, ["page"]);
+    const cacheKey = [
+        'channelUsers',
+        '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.channelUsers.length))
+        return;
+    const channelUsers = data.channelUsers
+        // ck -> cacheKey, abbrevated to avoid confusion from the above cache key
+        .map(ck => pullFromCache(['channelUsers', '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 channelUsers.length === ((_b = data === null || data === void 0 ? void 0 : data.channelUsers) === null || _b === void 0 ? void 0 : _b.length)
+        ? { data: channelUsers, cachedAt, prevPage, nextPage }
+        : undefined;
 };
 
 /**
@@ -24343,13 +24876,14 @@ queryChannelMembers.locally = (query) => {
 const addChannelMembers = async (channelId, userIds) => {
     const client = getActiveClient();
     client.log('channel/addChannelMembers', channelId, userIds);
-    const { data } = await client.http.post(`/api/v3/channels/${encodeURIComponent(channelId)}/users`, { channelId, userIds });
+    const { data: payload } = await client.http.post(`/api/v3/channels/${encodeURIComponent(channelId)}/users`, { channelId, userIds });
+    const data = prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
-    fireEvent('v3.channel.didAddUsers', {
-        channels: data.channels,
-        channelUsers: data.channelUsers,
-    });
+    /*
+     * 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) })));
     const { channelUsers } = data;
     return !!channelUsers.find(channelUser => channelUser.channelId === channelId && channelUser.membership === 'member');
 };
@@ -24372,13 +24906,14 @@ const addChannelMembers = async (channelId, userIds) => {
 const removeChannelMembers = async (channelId, userIds) => {
     const client = getActiveClient();
     client.log('channel/removeChannelMembers', channelId, userIds);
-    const { data } = await client.http.delete(`/api/v3/channels/${encodeURIComponent(channelId)}/users`, { data: { channelId, userIds } });
+    const { data: payload } = await client.http.delete(`/api/v3/channels/${encodeURIComponent(channelId)}/users`, { data: { channelId, userIds } });
+    const data = prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
-    fireEvent('v3.channel.didRemoveUsers', {
-        channels: data.channels,
-        channelUsers: data.channelUsers,
-    });
+    /*
+     * should fire event for each user that was removed
+     */
+    userIds.forEach(id => fireEvent('v3.channel.didRemoveUsers', Object.assign(Object.assign({}, data), { channelUsers: data.channelUsers.filter(u => u.userId === id) })));
     const { channelUsers } = data;
     return !!channelUsers.find(channelUser => channelUser.channelId === channelId && channelUser.membership !== 'member');
 };
@@ -24402,7 +24937,8 @@ const removeChannelMembers = async (channelId, userIds) => {
 const addChannelMembersRole = async (channelId, roleId, userIds) => {
     const client = getActiveClient();
     client.log('channel/addChannelMembersRole', channelId, roleId, userIds);
-    const { data } = await client.http.post(`/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`, { channelId, role: roleId, userIds });
+    const { data: payload } = await client.http.post(`/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`, { channelId, role: roleId, userIds });
+    const data = prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
     const { channelUsers } = data;
@@ -24428,7 +24964,8 @@ const addChannelMembersRole = async (channelId, roleId, userIds) => {
 const removeChannelMembersRole = async (channelId, roleId, userIds) => {
     const client = getActiveClient();
     client.log('channel/removeChannelMembersRole', channelId, roleId, userIds);
-    const { data } = await client.http.delete(`/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`, { data: { channelId, role: roleId, userIds } });
+    const { data: payload } = await client.http.delete(`/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`, { data: { channelId, role: roleId, userIds } });
+    const data = prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
     const { channelUsers } = data;
@@ -24442,57 +24979,150 @@ const removeChannelMembersRole = async (channelId, roleId, userIds) => {
  * await banChannelMembers('channel-id-1', ['userId1', 'userId2'])
  * ```
  *
- * @param channelId of {@link Amity.Channel} from which the users should be banned
- * @param userIds of the {@link Amity.User}'s to be banned
- * @returns the updated {@link Amity.Membership}'s object
+ * @param channelId of {@link Amity.Channel} from which the users should be banned
+ * @param userIds of the {@link Amity.User}'s to be banned
+ * @returns the updated {@link Amity.Membership}'s object
+ *
+ * @category Channel API
+ * @async
+ * */
+const banChannelMembers = async (channelId, userIds) => {
+    const client = getActiveClient();
+    client.log('channel/banChannelMembers', { userIds, channelId });
+    const { data: payload } = await client.http.put(`/api/v3/channels/${channelId}/users/ban`, {
+        userIds,
+    });
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channelUsers } = preparedPayload;
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(preparedPayload, { cachedAt });
+    return {
+        data: channelUsers === null || channelUsers === void 0 ? void 0 : channelUsers.filter(user => user.membership === 'banned'),
+        cachedAt,
+    };
+};
+
+/**
+ * ```js
+ * import { unbanChannelMembers } from '@amityco/ts-sdk'
+ *
+ * await unbanChannelMembers('channel-id-1', ['userId1', 'userId2'])
+ * ```
+ *
+ * @param channelId of {@link Amity.Channel} where the users should be unbanned
+ * @param userIds of the {@link Amity.User}'s to be unbanned
+ * @returns the updated {@link Amity.Membership}'s object
+ *
+ * @category Channel API
+ * @async
+ * */
+const unbanChannelMembers = async (channelId, userIds) => {
+    const client = getActiveClient();
+    client.log('channel/unbanChannelMembers', { userIds, channelId });
+    const { data: payload } = await client.http.put(`/api/v3/channels/${encodeURIComponent(channelId)}/users/unban`, {
+        userIds,
+    });
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        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} channelId - 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 channel had begun.
+ *
+ * @category Message API
+ * @async
+ */
+const startReading = async (channelId, userId = getActiveClient().userId) => {
+    const client = getActiveClient();
+    client.log('message/startReading', { channelId });
+    const result = await synchronousWSCall(client, 'channel.startReading', {
+        channelId,
+    });
+    // TODO: Implement optimistic update for `readyToSegment`
+    // const cachedChannel = pullFromCache<Amity.Channel>(['channel', 'get', channelId]);
+    // const cachedMember = pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', userId]);
+    //
+    // if (cachedChannel && cachedMember) {
+    //   fireEvent('v3.channel.didMarkSeen', {
+    //     channelUsers: [
+    //       {
+    //         ...cachedMember.data,
+    //         readToSegment: cachedChannel.data.messageCount ?? 0,
+    //       },
+    //     ],
+    //     channels: [],
+    //     users: [],
+    //     files: [],
+    //   });
+    // }
+    return !!result;
+};
+
+/**
+ * ```js
+ * import { stopReading } from '@amityco/ts-sdk'
+ * const success = await stopReading('foo')
+ * ```
+ *
+ * Stop reading message inside channel
+ *
+ * @param {string} channelId - The channel ID to stop reading.
+ * @return {Promise<boolean>>} A success boolean if the channel reading was halted.
  *
- * @category Channel API
+ * @category Message API
  * @async
- * */
-const banChannelMembers = async (channelId, userIds) => {
+ */
+const stopReading = async (channelId) => {
     const client = getActiveClient();
-    client.log('channel/banChannelMembers', { userIds, channelId });
-    const payload = await client.http.put(`/api/v3/channels/${channelId}/users/ban`, {
-        userIds,
+    client.log('message/stopReading', { channelId });
+    const result = await synchronousWSCall(client, 'channel.stopReading', {
+        channelId,
     });
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(payload.data, { cachedAt });
-    const { channelUsers } = payload.data;
-    return {
-        data: channelUsers === null || channelUsers === void 0 ? void 0 : channelUsers.filter(user => user.membership === 'banned'),
-        cachedAt,
-    };
+    return !!result;
 };
 
 /**
  * ```js
- * import { unbanChannelMembers } from '@amityco/ts-sdk'
- *
- * await unbanChannelMembers('channel-id-1', ['userId1', 'userId2'])
+ * import { onChannelCreated } from '@amityco/ts-sdk'
+ * const dispose = onChannelCreated(channel => {
+ *   // ...
+ * })
  * ```
  *
- * @param channelId of {@link Amity.Channel} where the users should be unbanned
- * @param userIds of the {@link Amity.User}'s to be unbanned
- * @returns the updated {@link Amity.Membership}'s object
+ * Fired when any {@link Amity.Channel} have been created
  *
- * @category Channel API
- * @async
- * */
-const unbanChannelMembers = async (channelId, userIds) => {
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelCreated = (callback) => {
     const client = getActiveClient();
-    client.log('channel/unbanChannelMembers', { userIds, channelId });
-    const payload = await client.http.put(`/api/v3/channels/${encodeURIComponent(channelId)}/users/unban`, {
-        userIds,
-    });
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(payload.data, { cachedAt });
-    const { channelUsers } = payload.data;
-    return {
-        data: channelUsers === null || channelUsers === void 0 ? void 0 : channelUsers.filter(user => user.membership === 'member'),
-        cachedAt,
+    const filter = (payload) => {
+        const data = prepareChannelPayload(payload);
+        ingestInCache(data);
+        callback(data.channels[0]);
     };
+    return createEventSubscriber(client, 'onChannelCreated', 'v3.channel.didCreate', filter);
 };
 
 /**
@@ -24513,8 +25143,9 @@ const unbanChannelMembers = async (channelId, userIds) => {
 const onChannelUpdated = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        ingestInCache(payload);
-        callback(payload.channels[0]);
+        const data = prepareChannelPayload(payload);
+        ingestInCache(data);
+        callback(data.channels[0]);
     };
     return createEventSubscriber(client, 'onChannelUpdated', 'v3.channel.didUpdate', filter);
 };
@@ -24537,8 +25168,9 @@ const onChannelUpdated = (callback) => {
 const onChannelDeleted = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        ingestInCache(payload);
-        callback(payload.channels[0]);
+        const data = prepareChannelPayload(payload);
+        ingestInCache(data);
+        callback(data.channels[0]);
     };
     return createEventSubscriber(client, 'onChannelDeleted', 'v3.channel.didDelete', filter);
 };
@@ -24561,8 +25193,9 @@ const onChannelDeleted = (callback) => {
 const onChannelJoined = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        ingestInCache(payload);
-        callback(payload.channels[0]);
+        const data = prepareChannelPayload(payload);
+        ingestInCache(data);
+        callback(data.channels[0]);
     };
     return createEventSubscriber(client, 'onChannelJoined', 'v3.channel.didJoin', filter);
 };
@@ -24585,8 +25218,9 @@ const onChannelJoined = (callback) => {
 const onChannelLeft = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        ingestInCache(payload);
-        callback(payload.channels[0]);
+        const data = prepareChannelPayload(payload);
+        ingestInCache(data);
+        callback(data.channels[0]);
     };
     return createEventSubscriber(client, 'onChannelLeft', 'v3.channel.didLeave', filter);
 };
@@ -24609,8 +25243,11 @@ const onChannelLeft = (callback) => {
 const onChannelMemberAdded = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        ingestInCache(payload);
-        callback(payload.channels[0], payload.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);
 };
@@ -24633,12 +25270,95 @@ const onChannelMemberAdded = (callback) => {
 const onChannelMemberRemoved = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        ingestInCache(payload);
-        callback(payload.channels[0], payload.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);
 };
 
+/**
+ * ```js
+ * import { onChannelMemberBanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberBanned((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been banned from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelMemberBanned = (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.find(cu => cu.membership === 'banned'));
+    };
+    return createEventSubscriber(client, 'onChannelMemberBanned', 'v3.channel.didBan', filter);
+};
+
+/**
+ * ```js
+ * import { onChannelMemberUnbanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberUnbanned((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been unbanned from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelMemberUnbanned = (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.find(cu => cu.membership === 'none'));
+    };
+    return createEventSubscriber(client, 'onChannelMemberUnbanned', 'v3.channel.didUnban', filter);
+};
+
+/**
+ * ```js
+ * import { onChannelMemberRead } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberRead((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been read from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelMemberRead = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        const channelPayload = prepareChannelPayload(payload);
+        const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+        ingestInCache(preparedPayload);
+        callback(preparedPayload.channels[0], preparedPayload.channelUsers[0]);
+    };
+    return createEventSubscriber(client, 'onChannelMemberRead', 'v3.channel.didMarkSeen', filter);
+};
+
 /**
  * ```js
  * import { observeChannel } from '@amityco/ts-sdk'
@@ -24671,11 +25391,281 @@ const observeChannel = (channelId, callback) => {
             (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, result);
         (_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')));
-    runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));
+    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')), onChannelMemberRead(data => router({ data, loading: false, origin: 'event' }, 'onRead')));
+    runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));
+    return () => {
+        log(`observeChannel(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { observeChannels } from '@amityco/ts-sdk'
+ *
+ * let channels = []
+ * const unsub = observeChannels(channel => merge(channels, channel))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Channel} for a current user
+ *
+ * @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 Observer
+ */
+const observeChannels = (callback) => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    log(`observeChannels(tmpid: ${timestamp}) > listen`);
+    const disposers = [];
+    const router = (channel, action) => {
+        var _a, _b;
+        if (callback instanceof Function)
+            return callback(channel);
+        (_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')), onChannelMemberRead(data => router(data, 'onRead')));
+    return () => {
+        log(`observeChannels(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { liveChannels } from '@amityco/ts-sdk'
+ *
+ * let channels = []
+ * const unsub = liveChannels({
+ *   displayName: Amity.Channel['displayName'],
+ * }, response => merge(channels, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Channel}s
+ *
+ * @param params for querying channels
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the channels
+ *
+ * @category Channel Live Collection
+ */
+const liveChannels = (params, callback, config) => {
+    const { log, cache, userId } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveChannels(tmpid: ${timestamp}) > listen`);
+    const { limit: queryLimit } = params, queryParams = __rest(params, ["limit"]);
+    const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
+    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
+    const disposers = [];
+    const cacheKey = ['channel', 'collection', {}];
+    const responder = (data) => {
+        var _a, _b;
+        let channels = (_a = data.data
+            .map(channelId => pullFromCache(['channel', 'get', channelId]))
+            .filter(Boolean)
+            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+        channels = filterByPropEquality(channels, 'isDeleted', params.isDeleted);
+        channels = filterByPropEquality(channels, 'displayName', params.displayName);
+        if (params.types) {
+            channels = channels.filter(c => { var _a; return (_a = params.types) === null || _a === void 0 ? void 0 : _a.includes(c.type); });
+        }
+        if (params.tags) {
+            channels = channels.filter(c => { var _a; return (_a = c.tags) === null || _a === void 0 ? void 0 : _a.some(t => { var _a; return (_a = params.tags) === null || _a === void 0 ? void 0 : _a.includes(t); }); });
+        }
+        if (params.excludeTags) {
+            channels = channels.filter(c => { var _a; return !((_a = c.tags) === null || _a === void 0 ? void 0 : _a.some(t => { var _a; return (_a = params.excludeTags) === null || _a === void 0 ? void 0 : _a.includes(t); })); });
+        }
+        // userId is required to be able to filter channel by current active user
+        if (params.membership && userId) {
+            channels = filterByChannelMembership(channels, params.membership, userId);
+        }
+        const sortBy = params.sortBy || 'lastCreated';
+        if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
+            channels = channels.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+        }
+        /*
+         * The server returns channels with empty | null displayName's first before
+         * returning sorted list of channels with displayNames
+         *
+         * This section needs to be updated as displayNames can be null as well
+         */
+        if (sortBy === 'displayName') {
+            channels = channels
+                // this needs to be aligned with the backend data type
+                .map(c => (c.displayName ? c : Object.assign(Object.assign({}, c), { displayName: '' })))
+                // @ts-ignore
+                .sort(sortByDisplayName);
+        }
+        callback({
+            onNextPage: onFetch,
+            data: channels,
+            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (channel, action) => {
+        var _a;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        if (action === 'onCreate') {
+            collection.data = [...new Set([channel.channelId, ...collection.data])];
+            /*
+             * if the filter isDeleted is set, only collection item must be updated and not
+             * the collection
+             */
+        }
+        else if (action === 'onDelete' && !params.isDeleted) {
+            collection.data = collection.data.filter(c => c !== channel.channelId);
+        }
+        pushToCache(cacheKey, collection);
+        responder(collection);
+    };
+    const onFetch = () => {
+        var _a, _b, _c;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const channels = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        if (channels.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
+            return;
+        const query = createQuery(queryChannels, Object.assign(Object.assign({}, queryParams), { page: (_c = collection === null || collection === void 0 ? void 0 : collection.params.page) !== null && _c !== void 0 ? _c : { limit } }));
+        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
+            const data = {
+                loading,
+                error,
+                params: { page },
+                data: channels,
+            };
+            if (result) {
+                data.data = [...new Set([...channels, ...result.map(getResolver('channel'))])];
+            }
+            pushToCache(cacheKey, data);
+            responder(data);
+        }, queryOptions(policy));
+    };
+    disposers.push(onChannelCreated(channel => realtimeRouter(channel, 'onCreate')), onChannelDeleted(channel => realtimeRouter(channel, 'onDelete')), onChannelUpdated(channel => realtimeRouter(channel, 'onUpdate')), onChannelMemberRead(channel => realtimeRouter(channel, 'onRead')));
+    onFetch();
+    return () => {
+        log(`liveChannels(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { liveChannelMembers } from '@amityco/ts-sdk'
+ *
+ * let channelMembers = []
+ * const unsub = liveChannelMembers({
+ *   channelId: Amity.Channel['channelId'],
+ * }, response => merge(channelMembers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.ChannelUser}s
+ *
+ * @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
+             */
+            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')), onChannelMemberRead((_, member) => realtimeRouter(member, 'onMemberRead')));
+    onFetch();
     return () => {
-        log(`observeChannel(tmpid: ${timestamp}) > dispose`);
+        log(`liveChannelMembers(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
     };
 };
@@ -24757,6 +25747,190 @@ const onMessageDeleted = (callback) => {
     return createEventSubscriber(client, 'message/onMessageDeleted', 'v3.message.didDelete', filter);
 };
 
+/**
+ * ```js
+ * import { onMessageFetched } from '@amityco/ts-sdk'
+ * const dispose = onMessageFetched(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageFetched = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'message/onMessageFetched', 'v3.message.didFetch', filter);
+};
+
+/**
+ * ```js
+ * import { liveMessage } from '@amityco/ts-sdk'
+ *
+ * let messages = []
+ * const unsub = liveMessage(messageId, response => merge(messages, 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
+ *
+ * @category Message Live Object
+ */
+const liveMessage = (messageId, callback) => {
+    const { log, cache } = getActiveClient();
+    let message;
+    let isUnsyncedObject = false;
+    if (!cache) {
+        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveMessage(tmpid: ${timestamp}) > listen`);
+    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;
+    };
+    const realtimeRouter = (message, action) => {
+        dispatcher({ loading: false, data: message, origin: 'event' });
+    };
+    const onFetch = () => {
+        const query = createQuery(getMessage, messageId, true);
+        runQuery(query, ({ loading, data, error, origin, cachedAt }) => {
+            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+                dispatcher({
+                    data,
+                    origin,
+                    loading: false,
+                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
+                });
+                isUnsyncedObject = true;
+                disposers.forEach(fn => fn());
+            }
+            else if (!isUnsyncedObject) {
+                dispatcher({ loading, data, origin, error });
+            }
+            if (error) {
+                // Terminate observe functionality on error
+                disposers.forEach(fn => fn());
+            }
+        });
+    };
+    disposers.push(onMessageFetched(message => realtimeRouter(message)), onMessageUpdated(message => realtimeRouter(message)), onMessageDeleted(message => realtimeRouter(message)));
+    onFetch();
+    return () => {
+        log(`liveMessage(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { liveMessages } from '@amityco/ts-sdk'
+ *
+ * let messages = []
+ * const unsub = liveMessages({
+ *   channelId: Amity.Channel['channelId'];
+ * }, 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 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 Messages Live Collection
+ */
+const liveMessages = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveMessages(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 = ['message', 'collection', { channelId: params.channelId }];
+    const responder = (data) => {
+        var _a, _b;
+        let messages = (_a = data.data
+            .map(messageId => pullFromCache(['message', 'get', messageId]))
+            .filter(Boolean)
+            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+        /*
+         * for cases when message is deleted via RTE, this flag is used to get
+         * items fro cache that are deleted | !deleted
+         */
+        messages = filterByPropEquality(messages, 'isDeleted', params.isDeleted);
+        callback({
+            onNextPage: onFetch,
+            data: messages,
+            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (message, action) => {
+        var _a;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (params.channelId !== message.channelId || !collection)
+            return;
+        if (action === 'onCreate') {
+            collection.data = [...new Set([message.messageId, ...collection.data])];
+        }
+        else if (['onDelete'].includes(action)) {
+            collection.data = collection.data.filter(m => m !== message.messageId);
+        }
+        pushToCache(cacheKey, collection);
+        responder(collection);
+    };
+    const onFetch = () => {
+        var _a, _b, _c, _d, _e;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const messages = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        if (messages.length > 0 && !((_c = collection === null || collection === void 0 ? void 0 : collection.params) === null || _c === void 0 ? void 0 : _c.page))
+            return;
+        const query = createQuery(queryMessages, Object.assign(Object.assign({}, queryParams), { page: (_e = (_d = collection === null || collection === void 0 ? void 0 : collection.params) === null || _d === void 0 ? void 0 : _d.page) !== null && _e !== void 0 ? _e : { limit } }));
+        runQuery(query, ({ data: result, error, loading, prevPage: page }) => {
+            const data = {
+                loading,
+                error,
+                params: { page },
+                data: messages,
+            };
+            if (result) {
+                data.data = [...new Set([...messages, ...result.map(getResolver('message'))])];
+            }
+            pushToCache(cacheKey, data);
+            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')));
+    onFetch();
+    return () => {
+        log(`liveMessages(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 /**
  * ```js
  * import { observeMessage } from '@amityco/ts-sdk'
@@ -24779,6 +25953,7 @@ const observeMessage = (messageId, callback, policy = 'cache_then_server') => {
     const { log } = getActiveClient();
     const timestamp = Date.now();
     log(`observeMessage(tmpid: ${timestamp}) > listen`);
+    console.log('observeMessage will be deprecated on 15th November 2022, please use liveMessage instead.');
     // wrapper function to make sure
     const router = (result, action) => {
         var _a, _b, _c;
@@ -24812,7 +25987,6 @@ const observeMessage = (messageId, callback, policy = 'cache_then_server') => {
  *
  * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.Channel} object
  *
- * @param client the client to observe the message with
  * @param channelId 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
@@ -24843,16 +26017,17 @@ const observeMessages = (channelId, callback) => {
 const createCommunityEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
+        const unpackedPayload = unpackCommunityPayload(payload);
         if (!client.cache) {
             // TODO: here we are missing specific properties here!
-            callback(payload.communities[0]);
+            callback(unpackedPayload.communities[0]);
         }
         else {
-            ingestInCache(payload);
+            ingestInCache(unpackedPayload);
             const community = pullFromCache([
                 'community',
                 'get',
-                payload.communities[0].communityId,
+                unpackedPayload.communities[0].communityId,
             ]);
             callback(community.data);
         }
@@ -24888,21 +26063,23 @@ function getEventRelatedMember(event, payload) {
 const createCommunityMemberEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
+        const communityPayload = unpackCommunityPayload(payload);
+        const preparedPayload = prepareMembershipPayload(communityPayload, 'communityUsers');
         if (!client.cache) {
             // TODO: here we are missing specific properties here!
-            callback(payload.communities[0], getEventRelatedMember(event, payload));
+            callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
         }
         else {
-            ingestInCache(payload);
+            ingestInCache(preparedPayload);
             const community = pullFromCache([
                 'community',
                 'get',
-                payload.communities[0].communityId,
+                preparedPayload.communities[0].communityId,
             ]);
             const member = pullFromCache([
                 'communityUsers',
                 'get',
-                getResolver('communityUsers')(getEventRelatedMember(event, payload)),
+                getResolver('communityUsers')(getEventRelatedMember(event, preparedPayload)),
             ]);
             callback(community.data, member.data);
         }
@@ -25327,9 +26504,9 @@ const queryFollows = async (key, query) => {
     if (client.cache) {
         ingestInCache(payload, { cachedAt });
         const cacheKey = [
-            key,
+            'follow',
             'query',
-            Object.assign(Object.assign({}, params), { userId, options: Object.assign({}, page) }),
+            Object.assign(Object.assign({}, params), { userId, options: Object.assign({}, page), type: key }),
         ];
         pushToCache(cacheKey, { follows: follows.map(getResolver('follow')), paging });
     }
@@ -25344,7 +26521,11 @@ queryFollows.locally = (key, query) => {
     if (!client.cache)
         return;
     const { page } = query, params = __rest(query, ["page"]);
-    const queryKey = [key, 'query', Object.assign(Object.assign({}, params), { options: Object.assign({}, page) })];
+    const queryKey = [
+        'follow',
+        'query',
+        Object.assign(Object.assign({}, params), { options: Object.assign({}, page), type: key }),
+    ];
     const { data, cachedAt } = (_a = pullFromCache(queryKey)) !== null && _a !== void 0 ? _a : {};
     if (!(data === null || data === void 0 ? void 0 : data.follows.length)) {
         return;
@@ -25890,6 +27071,186 @@ const observeFollowings = (userId, callback) => {
     };
 };
 
+/**
+ * ```js
+ * import { liveFollowers } from '@amityco/ts-sdk'
+ *
+ * let followers = []
+ * const unsub = liveFollowers({
+ *   userId: Amity.User['userId'];
+ * }, response => merge(followers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.FollowStatus} followers for a given userId
+ *
+ * @param userId the user
+ * @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 Followers Live Collection
+ */
+const liveFollowers = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log('For using Live Collection feature you need to enable Cache!');
+    }
+    const timestamp = Date.now();
+    log(`liveFollowers(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 = ['follow', 'collection', { userId: params.userId, type: 'follower' }];
+    const responder = (data) => {
+        var _a, _b;
+        let followers = (_a = data.data
+            .map(key => pullFromCache(['follow', 'get', key]))
+            .filter(Boolean)
+            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+        if (params.status && params.status !== 'all') {
+            followers = filterByPropEquality(followers, 'status', params.status);
+        }
+        callback({
+            onNextPage: onFetch,
+            data: followers,
+            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (followStatus, action) => {
+        var _a;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (params.userId !== followStatus.to || !collection)
+            return;
+        if (['onDeclined', 'onCanceled', 'onUnfollowed', 'onDeleted'].includes(action)) {
+            collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
+        }
+        else if (['onRequested', 'onAccepted', 'onFollowed'].includes(action)) {
+            collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
+        }
+        pushToCache(cacheKey, collection);
+        responder(collection);
+    };
+    const onFetch = () => {
+        var _a, _b, _c, _d, _e;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const followers = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        if (followers.length > 0 && !((_c = collection === null || collection === void 0 ? void 0 : collection.params) === null || _c === void 0 ? void 0 : _c.page))
+            return;
+        const query = createQuery(queryFollowers, Object.assign(Object.assign({}, queryParams), { page: (_e = (_d = collection === null || collection === void 0 ? void 0 : collection.params) === null || _d === void 0 ? void 0 : _d.page) !== null && _e !== void 0 ? _e : { limit } }));
+        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
+            const data = {
+                loading,
+                error,
+                params: { page },
+                data: followers,
+            };
+            if (result) {
+                data.data = [...new Set([...followers, ...result.map(getResolver('follow'))])];
+            }
+            pushToCache(cacheKey, data);
+            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')));
+    onFetch();
+    return () => {
+        log(`liveFollowers(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { liveFollowings } from '@amityco/ts-sdk'
+ *
+ * let followings = []
+ * const unsub = liveFollowings({
+ *   userId: Amity.User['userId'];
+ * }, response => merge(followings, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.FollowStatus} followings for a given userId
+ *
+ * @param userId the user
+ * @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 Followings Live Collection
+ */
+const liveFollowings = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log('For using Live Collection feature you need to enable Cache!');
+    }
+    const timestamp = Date.now();
+    log(`liveFollowings(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 = ['follow', 'collection', { userId: params.userId, type: 'following' }];
+    const responder = (data) => {
+        var _a, _b;
+        let followings = (_a = data.data
+            .map(key => pullFromCache(['follow', 'get', key]))
+            .filter(Boolean)
+            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+        if (params.status && params.status !== 'all') {
+            followings = filterByPropEquality(followings, 'status', params.status);
+        }
+        callback({
+            onNextPage: onFetch,
+            data: followings,
+            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (followStatus, action) => {
+        var _a;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (params.userId !== followStatus.from || !collection)
+            return;
+        if (['onDeclined', 'onCanceled', 'onUnfollowed', 'onDeleted'].includes(action)) {
+            collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
+        }
+        else if (['onRequested', 'onAccepted', 'onFollowed'].includes(action)) {
+            collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
+        }
+        pushToCache(cacheKey, collection);
+        responder(collection);
+    };
+    const onFetch = () => {
+        var _a, _b, _c, _d, _e;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const followings = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        if (followings.length > 0 && !((_c = collection === null || collection === void 0 ? void 0 : collection.params) === null || _c === void 0 ? void 0 : _c.page))
+            return;
+        const query = createQuery(queryFollowings, Object.assign(Object.assign({}, queryParams), { page: (_e = (_d = collection === null || collection === void 0 ? void 0 : collection.params) === null || _d === void 0 ? void 0 : _d.page) !== null && _e !== void 0 ? _e : { limit } }));
+        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
+            const data = {
+                loading,
+                error,
+                params: { page },
+                data: followings,
+            };
+            if (result) {
+                data.data = [...new Set([...followings, ...result.map(getResolver('follow'))])];
+            }
+            pushToCache(cacheKey, data);
+            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')));
+    onFetch();
+    return () => {
+        log(`liveFollowings(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 /**
  * ```js
  * import { observePosts } from '@amityco/ts-sdk'
@@ -25998,7 +27359,7 @@ const observePost = (postId, callback, policy = 'cache_then_server') => {
 const livePosts = (params, callback, config) => {
     const { log, cache } = getActiveClient();
     if (!cache) {
-        console.log('For using Live Collection feature you need to enable Cache!');
+        console.log(ENABLE_CACHE_MESSAGE);
     }
     const timestamp = Date.now();
     log(`livePosts(tmpid: ${timestamp}) > listen`);
@@ -26836,4 +28197,4 @@ const createUserToken = async (apiKey, apiRegion, params) => {
     return { accessToken: data.accessToken };
 };
 
-export { API_REGIONS, SubscriptionLevels, VERSION$1 as VERSION, acceptFollower, addChannelMembers, addChannelMembersRole, addCommunityMembers, addCommunityMembersRoles, addReaction, approvePost, backupCache, banChannelMembers, closePoll, connectClient, createChannel, createClient, createComment, createCommunity, createFile, createImage, createMessage, createPoll, createPost, createQuery, createReport, createStream, createUserToken, createVideo, declineFollower, declinePost, deleteChannel, deleteComment, deleteCommunity, deleteFile, deleteMessage, deletePoll, deletePost, deleteReport, deleteStream, disableCache, disconnectClient, disposeStream, dropFromCache, enableCache, fileUrlWithSize, filterByPropEquality, follow, getActiveClient, getCategory, getChannel, getChannels, getComment, getCommentTopic, getComments, getCommunities, getCommunity, getCommunityTopic, getFile, getFollowInfo, getMessage, getMessages, getMyFollowersTopic, getMyFollowingsTopic, getNetworkTopic, getPoll, getPost, getPostTopic, getPosts, getRecommendedCommunities, getRole, getStream, getTopTrendingCommunities, getUser, getUserTopic, getUsers, isAfterBefore, isAfterBeforeRaw, isCachable, isConnected, isFetcher, isFresh, isLocal, isMutator, isOffline, isPaged, isReportedByMe, isSkipLimit, joinChannel, joinCommunity, leaveChannel, leaveCommunity, liveComments, livePosts, liveReactions, mergeInCache, observeChannel, observeComment, observeComments, observeCommunity, observeFile, observeFollowInfo, observeFollowers, observeFollowings, observeMessage, observeMessages, observePoll, observePost, observePosts, observeUser, onChannelDeleted, onChannelJoined, onChannelLeft, onChannelMemberAdded, onChannelMemberRemoved, onChannelUpdated, onClientBanned, onClientDisconnected, onCommentCreated, onCommentDeleted, onCommentFlagged, onCommentReactionAdded, onCommentReactionRemoved, onCommentUnflagged, onCommentUpdated, onCommunityCreated, onCommunityDeleted, onCommunityJoined, onCommunityLeft, onCommunityUpdated, onCommunityUserAdded, onCommunityUserBanned, onCommunityUserRemoved, onCommunityUserUnbanned, onConnectionError, onFollowInfoUpdated, onFollowRequestAccepted, onFollowRequestCanceled, onFollowRequestDeclined, onFollowerDeleted, onFollowerRequested, onMessageCreated, onMessageDeleted, onMessageUpdated, onPollDeleted, onPollUpdated, onPostApproved, onPostCreated, onPostDeclined, onPostDeleted, onPostFlagged, onPostReactionAdded, onPostReactionRemoved, onPostUnflagged, onPostUpdated, onReactionAdded, onReactionRemoved, onReactorAdded, onReactorRemoved, onStreamRecorded, onStreamStarted, onStreamStopped, onUserDeleted, onUserFlagCleared, onUserFlagged, onUserFollowed, onUserUnflagged, onUserUnfollowed, onUserUpdated, pullFromCache, pushToCache, queryCache, queryCategories, queryChannelMembers, queryChannels, queryComments, queryCommunities, queryCommunityMembers, queryFollowers, queryFollowings, queryGlobalFeed, queryMessages, queryOptions, queryPosts, queryReactions, queryRoles, queryStreams, queryUsers, removeChannelMembers, removeChannelMembersRole, removeCommunityMembers, removeCommunityMembersRoles, removeReaction, restoreCache, runQuery, sortByChannelSegment, sortByDisplayName, sortByFirstCreated, sortByLastActivity, sortByLastCreated, sortBySegmentNumber, subscribeTopic, toPage, toPageRaw, toToken, unbanChannelMembers, unfollow, updateChannel, updateComment, updateCommunity, updateMessage, updatePost, updateStream, updateUser, upsertInCache, votePoll, wipeCache };
+export { API_REGIONS, CommunityPostSettingMaps, CommunityPostSettings, ContentFeedType, DefaultCommunityPostSetting, FileType, MessageContentType, PostContentType, SubscriptionLevels, VERSION$1 as VERSION, VideoResolution, VideoSize, VideoTranscodingStatus, acceptFollower, addChannelMembers, addChannelMembersRole, addCommunityMembers, addCommunityMembersRoles, addReaction, approvePost, backupCache, banChannelMembers, closePoll, connectClient, createChannel, createClient, createComment, createCommunity, createFile, createImage, createMessage, createPoll, createPost, createQuery, createReport, createStream, createUserToken, createVideo, declineFollower, declinePost, deleteChannel, deleteComment, deleteCommunity, deleteFile, deleteMessage, deletePoll, deletePost, deleteReport, deleteStream, disableCache, disconnectClient, disposeStream, dropFromCache, enableCache, fileUrlWithSize, filterByChannelMembership, filterByPropEquality, filterByPropInclusion, follow, getActiveClient, getCategory, getChannel, getChannels, getComment, getCommentTopic, getComments, getCommunities, getCommunity, getCommunityTopic, getFeedSettings, getFile, getFollowInfo, getMessage, getMessages, getMyFollowersTopic, getMyFollowingsTopic, getNetworkTopic, getPoll, getPost, getPostTopic, getPosts, getRecommendedCommunities, getRole, getStream, getTopTrendingCommunities, getUser, getUserTopic, getUsers, isAfterBefore, isAfterBeforeRaw, isCachable, isConnected, isFetcher, isFresh, isLocal, isMutator, isOffline, isPaged, isReportedByMe, isSkipLimit, joinChannel, joinCommunity, leaveChannel, leaveCommunity, liveChannelMembers, liveChannels, liveComments, liveFollowers, liveFollowings, liveMessage, liveMessages, livePosts, liveReactions, liveUser, mergeInCache, observeChannel, observeChannels, observeComment, observeComments, observeCommunity, observeFile, observeFollowInfo, observeFollowers, observeFollowings, observeMessage, observeMessages, observePoll, observePost, observePosts, observeUser, onChannelCreated, onChannelDeleted, onChannelJoined, onChannelLeft, onChannelMemberAdded, onChannelMemberBanned, onChannelMemberRead, onChannelMemberRemoved, onChannelMemberUnbanned, onChannelUpdated, onClientBanned, onClientDisconnected, onCommentCreated, onCommentDeleted, onCommentFlagged, onCommentReactionAdded, onCommentReactionRemoved, onCommentUnflagged, onCommentUpdated, onCommunityCreated, onCommunityDeleted, onCommunityJoined, onCommunityLeft, onCommunityUpdated, onCommunityUserAdded, onCommunityUserBanned, onCommunityUserRemoved, onCommunityUserUnbanned, onConnectionError, onFollowInfoUpdated, onFollowRequestAccepted, onFollowRequestCanceled, onFollowRequestDeclined, onFollowerDeleted, onFollowerRequested, onMessageCreated, onMessageDeleted, onMessageFetched, onMessageUpdated, onPollDeleted, onPollUpdated, onPostApproved, onPostCreated, onPostDeclined, onPostDeleted, onPostFlagged, onPostReactionAdded, onPostReactionRemoved, onPostUnflagged, onPostUpdated, onReactionAdded, onReactionRemoved, onReactorAdded, onReactorRemoved, onStreamRecorded, onStreamStarted, onStreamStopped, onUserDeleted, onUserFetched, onUserFlagCleared, onUserFlagged, onUserFollowed, onUserUnflagged, onUserUnfollowed, onUserUpdated, pullFromCache, pushToCache, queryCache, queryCategories, queryChannelMembers, queryChannels, queryComments, queryCommunities, queryCommunityMembers, queryFollowers, queryFollowings, queryGlobalFeed, queryMessages, queryOptions, queryPosts, queryReactions, queryRoles, queryStreams, queryUsers, removeChannelMembers, removeChannelMembersRole, removeCommunityMembers, removeCommunityMembersRoles, removeReaction, restoreCache, runQuery, sortByChannelSegment, sortByDisplayName, sortByFirstCreated, sortByLastActivity, sortByLastCreated, sortBySegmentNumber, startReading, stopReading, subscribeTopic, toPage, toPageRaw, toToken, unbanChannelMembers, unfollow, updateChannel, updateComment, updateCommunity, updateMessage, updatePost, updateStream, updateUser, upsertInCache, votePoll, wipeCache };