@amityco/ts-sdk 0.0.1-beta.42.3 → 0.0.1-beta.43

package/dist/index.cjs.js

@@ -95,8 +95,8 @@ const PostContentType = Object.freeze({
 
 function getVersion() {
     try {
-        // the string ''v0.0.1-beta.42.3-cjs'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v0.0.1-beta.42.3-cjs';
+        // the string ''v0.0.1-beta.43-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v0.0.1-beta.43-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -514,6 +514,11 @@ const idResolvers = {
     subChannel: ({ subChannelId }) => subChannelId,
     channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
     message: ({ messageId }) => messageId,
+    channelMarker: ({ entityId, userId }) => `${entityId}#${userId}`,
+    subChannelMarker: ({ entityId, feedId, userId }) => `${entityId}#${feedId}#${userId}`,
+    messageMarker: ({ feedId, contentId, creatorId }) => `${feedId}#${contentId}#${creatorId}`,
+    feedMarker: ({ feedId, entityId }) => `${feedId}#${entityId}`,
+    userMarker: ({ userId }) => userId,
     community: ({ communityId }) => communityId,
     category: ({ categoryId }) => categoryId,
     communityUsers: ({ communityId, userId }) => `${communityId}#${userId}`,
@@ -614,6 +619,11 @@ const PAYLOAD2MODEL = {
     messageFeeds: 'subChannel',
     channelUsers: 'channelUsers',
     messages: 'message',
+    userEntityMarkers: 'channelMarker',
+    userFeedMarkers: 'subChannelMarker',
+    contentMarkers: 'messageMarker',
+    feedMarkers: 'feedMarker',
+    userMarkers: 'userMarker',
     communities: 'community',
     categories: 'category',
     communityUsers: 'communityUsers',
@@ -20530,6 +20540,57 @@ const setClientToken = async (params) => {
     return { accessToken, users, refreshToken };
 };
 
+/**
+ * Ingest a payload (v3) into the cache
+ *
+ * @param payload a "backend v3" payload object
+ * @param options caching options like cachedAt or offline
+ *
+ * @category Cache
+ * @hidden
+ */
+const ingestInCache = (payload = {}, options) => {
+    Object.entries(payload).forEach(([key, models]) => {
+        const type = PAYLOAD2MODEL[key];
+        if (!type)
+            return;
+        const resolver = getResolver(type);
+        if (!resolver)
+            return;
+        models.forEach(model => {
+            upsertInCache([type, 'get', resolver(model)], model, options);
+        });
+    });
+};
+
+const createUserEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        if (client.cache) {
+            ingestInCache(payload);
+        }
+        callback(payload.users[0]);
+    };
+    return createEventSubscriber(client, event, event, filter);
+};
+
+/**
+ * ```js
+ * import { onUserDeleted } from '@amityco/ts-sdk'
+ * const dispose = onUserDeleted(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+const onUserDeleted = (callback) => createUserEventSubscriber('user.deleted', callback);
+
 /* begin_public_function
   id: client.logout
 */
@@ -20584,57 +20645,6 @@ const disconnectClient = async () => {
 };
 /* end_public_function */
 
-/**
- * Ingest a payload (v3) into the cache
- *
- * @param payload a "backend v3" payload object
- * @param options caching options like cachedAt or offline
- *
- * @category Cache
- * @hidden
- */
-const ingestInCache = (payload = {}, options) => {
-    Object.entries(payload).forEach(([key, models]) => {
-        const type = PAYLOAD2MODEL[key];
-        if (!type)
-            return;
-        const resolver = getResolver(type);
-        if (!resolver)
-            return;
-        models.forEach(model => {
-            upsertInCache([type, 'get', resolver(model)], model, options);
-        });
-    });
-};
-
-const createUserEventSubscriber = (event, callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        if (client.cache) {
-            ingestInCache(payload);
-        }
-        callback(payload.users[0]);
-    };
-    return createEventSubscriber(client, event, event, filter);
-};
-
-/**
- * ```js
- * import { onUserDeleted } from '@amityco/ts-sdk'
- * const dispose = onUserDeleted(user => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.User} has been deleted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category User Events
- */
-const onUserDeleted = (callback) => createUserEventSubscriber('user.deleted', callback);
-
 /**
  * Terminates {@link Amity.Client} instance
  *
@@ -21090,408 +21100,355 @@ const isConnected = () => {
 
 /**
  * ```js
- * import { isInTombstone } from '@amityco/ts-sdk'
- * const user = isInTombstone(["message", "messageId"])
+ * import { markerSync } from '@amityco/ts-sdk'
+ * const success = await markerSync()
  * ```
  *
- * Checks if the {@link Amity.TombstoneCacheOptions} exists
- * in cache and it's not expired means it's in tombstone
- * and we throw an Error
+ * Make all markers synced
+ * * If response is empty means that the sync has ended.
+ * * If response is not empty, the sync has not ended. You must call markerSync
+ * again to continue syncing.
  *
- * @param model the model to check
- * @param modelId the object id to check
- * @returns the matching cache entry, or undefined.
+ * @return {hasMore} A success boolean if the marker sync was ended.
  *
- * @category Cache API
+ * @category Marker API
+ * @async
+ * @private
  */
-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 */);
-    }
+const markerSync = async () => {
+    const client = getActiveClient();
+    client.log('channel/markerSync');
+    const { data: payload } = await client.http.post(`/api/v1/markers/sync`);
+    const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(payload, { cachedAt });
+    feedMarkers.length && fireEvent('local.feedMarker.fetched', { feedMarkers });
+    userEntityMarkers.length && fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+    userFeedMarkers.length && fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+    userMarkers.length && fireEvent('local.userMarker.fetched', { userMarkers });
+    return {
+        hasMore: payload.feedMarkers.length > 0,
+    };
 };
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
 /**
  * ```js
- * import { pushToTombstone } from '@amityco/ts-sdk'
- * pushToTombstone(["message", "messageId"], { cachedAt: Date.now() })
+ * import { getChannelMarker } from '@amityco/ts-sdk'
+ * const channelMarkers = await getChannelMarkers(['ch1', 'ch2'])
  * ```
  *
- * Removes an existing {@link Amity.CacheEntry} from the {@link Amity.Client}'s
- * {@link Amity.Cache} from a given {@link Amity.CacheKey}
+ * Fetches a paginable list of {@link Amity.ChannelMarker} objects
  *
- * @param model the model to remove and push to Tombstone
- * @param modelId the related model id
+ * @param channelIds the IDs of the {@link Amity.RawChannel} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.ChannelMarker} objects
  *
- * @category Cache API
- * @hidden
+ * @category Channel API
+ * @async
+ * @private
  */
-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);
+const getChannelMarkers = async (channelIds, page = { limit: 100 }) => {
+    const client = getActiveClient();
+    client.log('channel/getChannelMarkers', channelIds, page);
+    const { data: queryPayload } = await client.http.get(`/api/v1/markers/channels`, {
+        params: {
+            channelIds,
+            options: {
+                token: toToken(page, 'skiplimit'),
+            },
+        },
+    });
+    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
+    const { userEntityMarkers, userMarkers } = payload;
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(payload, { cachedAt });
+    userEntityMarkers.length && fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+    userMarkers.length && fireEvent('local.userMarker.fetched', { userMarkers });
+    const nextPage = toPage(paging.next);
+    const prevPage = toPage(paging.previous);
+    return { data: userEntityMarkers, cachedAt, prevPage, nextPage };
 };
 
-/* begin_public_function
-  id: user.get
-*/
 /**
  * ```js
- * import { getUser } from '@amityco/ts-sdk'
- * const { data: user } = await getUser('foobar')
+ * import { getMessageMarkers } from '@amityco/ts-sdk'
+ * const messageMarkers = await getMessageMarkers(['sch1', 'sch2'])
  * ```
  *
- * Fetches a {@link Amity.User} object
+ * Fetches a paginable list of {@link Amity.MessageMarker} objects
  *
- * @param userId the ID of the {@link Amity.User} to fetch
- * @returns the associated {@link Amity.User} object
+ * @param messageIds the feed IDs of the {@link Amity.RawMessage} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.MessageMarker} objects
  *
- * @category User API
+ * @category Channel API
  * @async
+ * @private
  */
-const getUser = async (userId, isLive = false) => {
+const getMessageMarkers = async (messageIds, page = { limit: 100 }) => {
     const client = getActiveClient();
-    client.log('user/getUser', 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;
-    }
+    client.log('channel/getMessageMarkers', messageIds, page);
+    const { data: queryPayload } = await client.http.get(`/api/v1/markers/messages`, {
+        params: {
+            messageIds,
+            options: {
+                token: toToken(page, 'skiplimit'),
+            },
+        },
+    });
+    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
+    const { contentMarkers, feedMarkers, userMarkers } = payload;
     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,
-    };
-};
-/* end_public_function */
+        ingestInCache(payload, { cachedAt });
+    feedMarkers.length && fireEvent('local.feedMarker.fetched', { feedMarkers });
+    contentMarkers.length && fireEvent('local.messageMarker.fetched', { contentMarkers });
+    userMarkers.length && fireEvent('local.userMarker.fetched', { userMarkers });
+    const nextPage = toPage(paging.next);
+    const prevPage = toPage(paging.previous);
+    return { data: contentMarkers, cachedAt, prevPage, nextPage };
+};
+
 /**
  * ```js
- * import { getUser } from '@amityco/ts-sdk'
- * const { data: user } = getUser.locally('foobar')
+ * import { getSubChannelMarkers } from '@amityco/ts-sdk'
+ * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
  * ```
  *
- * Fetches a {@link Amity.User} object from cache
+ * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
  *
- * @param userId the ID of the {@link Amity.User} to fetch
- * @returns the associated {@link Amity.User} object
+ * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.SubChannelMarker} objects
  *
- * @category User API
+ * @category Channel API
+ * @async
+ * @private
  */
-getUser.locally = (userId) => {
+const getSubChannelMarkers = async (messageFeedIds, page = { limit: 100 }) => {
     const client = getActiveClient();
-    client.log('user/getUser.locally', userId);
-    return client.cache && pullFromCache(['user', 'get', userId]);
+    client.log('channel/getSubChannelMarkers', messageFeedIds, page);
+    const { data: queryPayload } = await client.http.get(`/api/v1/markers/message-feeds`, {
+        params: {
+            messageFeedIds,
+            options: {
+                token: toToken(page, 'skiplimit'),
+            },
+        },
+    });
+    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
+    const { userEntityMarkers, userFeedMarkers, userMarkers } = payload;
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(payload, { cachedAt });
+    userEntityMarkers.length && fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+    userFeedMarkers.length && fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+    userMarkers.length && fireEvent('local.userMarker.fetched', { userMarkers });
+    const nextPage = toPage(paging.next);
+    const prevPage = toPage(paging.previous);
+    return { data: userFeedMarkers, cachedAt, prevPage, nextPage };
 };
 
-/* begin_public_function
-  id: user.get_by_ids
-*/
-/**
- * ```js
- * import { getUsers } from '@amityco/ts-sdk'
- * const { data: users } = await getUsers(['foo', 'bar'])
- * ```
- *
- * Fetches a collection of {@link Amity.User} objects
- *
- * @param userIds the IDs of the {@link Amity.User} to fetch
- * @returns the associated collection of {@link Amity.User} objects
- *
- * @category User API
- * @async
- */
-const getUsers = async (userIds) => {
+const locally = () => {
+    var _a, _b;
     const client = getActiveClient();
-    client.log('user/getUsers', userIds);
-    const encodedUserIds = userIds.map(userId => encodeURIComponent(userId));
-    // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const { data } = await client.http.get(`/api/v3/users/list`, {
-        params: { userIds: encodedUserIds },
-    });
+    const user = getActiveUser();
+    client.log('marker/getUserMarker.locally');
+    const { _id: userId } = user;
+    if (!userId)
+        throw new ASCError('The userId has not been defined in active client', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+    const createdTime = new Date().toISOString();
     const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    fireEvent('user.fetched', data);
+    const data = (_b = (_a = pullFromCache([
+        'userMarker',
+        'get',
+        getResolver('userMarker')({ userId }),
+    ])) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : {
+        userId,
+        unreadCount: 0,
+        lastSyncAt: createdTime,
+        createdAt: createdTime,
+        updatedAt: createdTime,
+    };
     return {
-        data: data.users,
+        data,
         cachedAt,
     };
 };
-/**
- * ```js
- * import { getUsers } from '@amityco/ts-sdk'
- * const { data: users } = getUsers.locally!(['foo', 'bar'])
- * ```
- *
- * Fetches a collection of {@link Amity.User} objects from cache
- *
- * @param userIds the IDs of the {@link Amity.User} to fetch
- * @returns the associated collection of {@link Amity.User} objects
- *
- * @category User API
- */
-getUsers.locally = (userIds) => {
-    var _a;
-    const client = getActiveClient();
-    client.log('user/getUsers.locally', userIds);
-    if (!client.cache)
-        return;
-    const cached = userIds
-        .map(userId => pullFromCache(['user', 'get', userId]))
-        .filter(Boolean);
-    const users = cached.map(({ data }) => data);
-    const oldest = (_a = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _a === void 0 ? void 0 : _a[0];
-    if ((cached === null || cached === void 0 ? void 0 : cached.length) < userIds.length)
-        return;
-    return {
-        data: users,
-        cachedAt: oldest.cachedAt,
-    };
-};
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-/* begin_public_function
-  id: user.query, user.search
-*/
-/**
- * ```js
- * import { queryUsers } from '@amityco/ts-sdk'
- * const { data: users, prevPage, nextPage } = await queryUsers({ displayName: 'foo' })
- * ```
- *
- * Queries a paginable list of {@link Amity.User} objects
- * Search is performed by displayName such as `.startsWith(search)`
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
- *
- * @category User API
- * @async
- */
-const queryUsers = async (query = {}) => {
-    const client = getActiveClient();
-    client.log('user/queryUsers', query);
-    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: {
-                token: toToken(page, 'skiplimit'),
-            } }),
-    });
-    // unpacking
-    const { paging } = data, payload = __rest(data, ["paging"]);
-    const { users } = payload;
-    const cachedAt = client.cache && Date.now();
-    if (client.cache) {
-        ingestInCache(payload, { cachedAt });
-        /*
-         * 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 };
+const getUserMarker = () => {
+    // API-FIX: backend should implement user marker get API
+    return Promise.resolve(locally());
 };
-/* end_public_function */
+getUserMarker.locally = locally;
+
 /**
  * ```js
- * import { queryUsers } from '@amityco/ts-sdk'
- * const { data: users } = queryUsers.locally({ keyword: 'foo' })
+ * import { onChannelMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onChannelMarkerFetched(channelMarker => {
+ *   // ...
+ * })
  * ```
  *
- * Queries a paginable list of {@link Amity.User} objects from cache
- * Search is performed by displayName such as `.startsWith(search)`
+ * Fired when an {@link Amity.ChannelMarker} has been fetched
  *
- * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category User API
+ * @category ChannelMarker Events
  */
-queryUsers.locally = (query = {}) => {
-    var _a, _b, _c;
+const onChannelMarkerFetched = (callback) => {
     const client = getActiveClient();
-    client.log('user/queryUsers.locally', query);
-    if (!client.cache)
-        return;
-    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);
-    return users.length > 0 && users.length === ((_c = data === null || data === void 0 ? void 0 : data.users) === null || _c === void 0 ? void 0 : _c.length)
-        ? { data: users, cachedAt, prevPage, nextPage }
-        : undefined;
+    const filter = (payload) => {
+        callback(payload.userEntityMarkers[0]);
+    };
+    return createEventSubscriber(client, 'channelMarker/onChannelMarkerFetched', 'local.channelMarker.fetched', filter);
 };
 
-/* begin_public_function
-  id: client.update_user
-*/
 /**
  * ```js
- * import { updateUser } from '@amityco/ts-sdk'
- * const updated = await updateUser(userId, { displayName: 'foobar' })
+ * import { onSubChannelMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelMarkerFetched(subChannelMarker => {
+ *   // ...
+ * })
  * ```
  *
- * Updates an {@link Amity.User}
+ * Fired when an {@link Amity.SubChannelMarker} has been fetched
  *
- * @param userId The ID of the {@link Amity.User} to update
- * @param patch The patch data to apply
- * @returns the updated {@link Amity.User} object
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category User API
- * @async
+ * @category SubChannelMarker Events
  */
-const updateUser = async (userId, patch) => {
+const onSubChannelMarkerFetched = (callback) => {
     const client = getActiveClient();
-    client.log('user/updateUser', userId, patch);
-    // API-FIX: Endpoint is malformed, userId should be a url param.
-    /*
-      const { data } = await client.http.put<Amity.Response<UserPayload>>(
-        `/api/v3/users/${userId}`, patch,
-      )
-    */
-    const { data } = await client.http.put(`/api/v3/users/`, Object.assign(Object.assign({ userId }, patch), { createNewUserWhenNotFound: false }));
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { users } = data;
-    fireEvent('user.updated', data);
-    return {
-        data: users.find(user => user.userId === userId),
-        cachedAt,
+    const filter = (payload) => {
+        callback(payload.userFeedMarkers[0]);
     };
-};
-/* end_public_function */
+    return createEventSubscriber(client, 'subChannelMarker/onSubChannelMarkerFetched', 'local.subChannelMarker.fetched', filter);
+};
 
 /**
  * ```js
- * import { onUserUpdated } from '@amityco/ts-sdk'
- * const dispose = onUserUpdated(user => {
+ * import { onSubChannelMarkerUpdated } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelMarkerUpdated(subChannelMarker => {
  *   // ...
  * })
  * ```
  *
- * Fired when a {@link Amity.User} has been updated
+ * Fired when an {@link Amity.SubChannelMarker} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category User Events
+ * @category SubChannelMarker Events
  */
-const onUserUpdated = (callback) => createUserEventSubscriber('user.updated', callback);
+const onSubChannelMarkerUpdated = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        callback(payload.userFeedMarkers[0]);
+    };
+    return createEventSubscriber(client, 'subChannelMarker/onSubChannelMarkerUpdated', 'local.subChannelMarker.updated', filter);
+};
 
 /**
  * ```js
- * import { onUserFlagged } from '@amityco/ts-sdk'
- * const dispose = onUserFlagged(user => {
+ * import { onFeedMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onFeedMarkerFetched(feedMarker => {
  *   // ...
  * })
  * ```
  *
- * Fired when a {@link Amity.User} has been flagged
+ * Fired when an {@link Amity.FeedMarker} 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
+ * @category FeedMarker Events
  */
-const onUserFlagged = (callback) => createUserEventSubscriber('user.flagged', callback);
+const onFeedMarkerFetched = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        callback(payload.feedMarkers[0]);
+    };
+    return createEventSubscriber(client, 'feedMarker/onFeedMarkerFetched', 'local.feedMarker.fetched', filter);
+};
 
 /**
  * ```js
- * import { onUserUnflagged } from '@amityco/ts-sdk'
- * const dispose = onUserUnflagged(user => {
+ * import { onUserMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onUserMarkerFetched(userMarker => {
  *   // ...
  * })
  * ```
  *
- * Fired when a flag has been removed from a {@link Amity.User}
+ * Fired when an {@link Amity.UserMarker} 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
+ * @category UserMarker Events
  */
-const onUserUnflagged = (callback) => createUserEventSubscriber('user.unflagged', callback);
+const onUserMarkerFetched = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        callback(payload.userMarkers[0]);
+    };
+    return createEventSubscriber(client, 'userMarker/onUserMarkerFetched', 'local.userMarker.fetched', filter);
+};
 
 /**
  * ```js
- * import { onUserFlagCleared } from '@amityco/ts-sdk'
- * const dispose = onUserFlagCleared(user => {
+ * import { onMessageMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onMessageMarkerFetched(messageMarker => {
  *   // ...
  * })
  * ```
  *
- * Fired when flags have been cleared for a {@link Amity.User}
+ * Fired when an {@link Amity.MessageMarker} 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
+ * @category MessageMarker Events
  */
-const onUserFlagCleared = (callback) => createUserEventSubscriber('user.flagCleared', callback);
+const onMessageMarkerFetched = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        callback(payload.contentMarkers[0]);
+    };
+    return createEventSubscriber(client, 'messageMarker/onMessageMarkerFetched', 'local.messageMarker.fetched', filter);
+};
 
-const liveObject = (id, callback, key, fetcher, eventHandlers) => {
+const liveObject = (id, callback, key, fetcher, eventHandlers, callbackDataSelector = data => data, callbackFilter) => {
     const { cache } = getActiveClient();
     if (!cache) {
         console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
@@ -21500,8 +21457,11 @@ const liveObject = (id, callback, key, fetcher, eventHandlers) => {
     let isUnsyncedModel = false; // for messages
     const disposers = [];
     const dispatcher = (data) => {
-        model = data.data;
-        callback(data);
+        const { data: newModel } = data, rest = __rest(data, ["data"]);
+        if (!callbackFilter || callbackFilter(newModel, model)) {
+            callback(Object.assign({ data: callbackDataSelector(newModel) }, rest));
+        }
+        model = newModel;
     };
     const realtimeRouter = (eventModel) => {
         if (id !== eventModel[key]) {
@@ -21545,22 +21505,1255 @@ const liveObject = (id, callback, key, fetcher, eventHandlers) => {
 
 /**
  * ```js
- * import { onUserFetched } from '@amityco/ts-sdk'
- * const dispose = onUserFetched(user => {
- *   // ...
- * })
+ * import { getTotalUnreadCount } from '@amityco/ts-sdk';
+ *
+ * const unsubscribe = getTotalUnreadCount(response => {
+ *   totalUnreadCount = response.data;
+ * });
  * ```
  *
- * Fired when a {@link Amity.User} has been fetched
+ * Observe current user's unread count from {@link Amity.UserMarker}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @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 events
  *
- * @category User Events
+ * @category Message Live Object
  */
-const onUserFetched = (callback) => createUserEventSubscriber('user.fetched', callback);
+const getTotalUnreadCount = (callback) => {
+    const { _id: userId } = getActiveUser();
+    if (!userId)
+        throw new ASCError('The _id has not been defined in ActiveUser', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+    const callbackPayloadSelector = (data) => { var _a; return (_a = data === null || data === void 0 ? void 0 : data.unreadCount) !== null && _a !== void 0 ? _a : 0; };
+    // based on the mobile specs, unreadCount will not trigger observer when userMarker
+    // is re-fetched, so apply this filter to ensure the behavior is the same.
+    const callbackFilter = (newModel, oldModel) => (newModel === null || newModel === void 0 ? void 0 : newModel.unreadCount) !== (oldModel === null || oldModel === void 0 ? void 0 : oldModel.unreadCount);
+    return liveObject(userId, callback, 'userId', getUserMarker, [onUserMarkerFetched], callbackPayloadSelector, callbackFilter);
+};
 
-/**
+/** @hidden */
+/*
+ * @param message payload from http request without myReactions
+ * add myReactions to http response if the event was a reaction event
+ */
+const prepareMessagePayloadForCache = (payload) => {
+    const client = getActiveClient();
+    const cached = pullFromCache(['message', 'get', payload.messageId]);
+    // '[]' in cases where the new reaction is the first one
+    const myReactions = (cached === null || cached === void 0 ? void 0 : cached.data.myReactions) || [];
+    // add myReactions to the payload
+    Object.assign(payload, { myReactions });
+    // check if there are any updates to the reactions
+    const latestReaction = payload === null || payload === void 0 ? void 0 : payload.latestReaction;
+    const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
+    if (!isLatestReactionMine) {
+        return;
+    }
+    // new reaction added
+    if (latestReaction.eventName === 'add' && !myReactions.includes(latestReaction.reactionName)) {
+        Object.assign(payload, {
+            myReactions: [...myReactions, latestReaction.reactionName],
+        });
+    }
+    // existing reaction removed
+    if (latestReaction.eventName === 'remove' && myReactions.includes(latestReaction.reactionName)) {
+        Object.assign(payload, {
+            myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
+        });
+    }
+};
+
+const getCachedMarker$1 = (message) => {
+    var _a, _b;
+    const key = {
+        creatorId: message.creatorId,
+        feedId: (_a = message.messageFeedId) !== null && _a !== void 0 ? _a : message.subChannelId,
+        contentId: message.messageId,
+    };
+    return (_b = pullFromCache([
+        'messageMarker',
+        'get',
+        getResolver('messageMarker')(key),
+    ])) === null || _b === void 0 ? void 0 : _b.data;
+};
+const getReadCount = (message, marker) => {
+    var _a;
+    // Look in the marker param first
+    return (_a = marker !== null && marker !== void 0 ? marker : 
+    // If the marker param is not set, look in the cache
+    getCachedMarker$1(message)) !== null && _a !== void 0 ? _a : { readCount: 0, deliveredCount: 0 };
+}; // and if not found in cache use default value `0`
+function convertFromRaw$2(message, marker) {
+    const { channelPublicId, childCount, creatorPublicId, mentionedUsers, messageFeedId, myReactions, reactionCount, reactions, referenceId, segment, messageId } = message, rest = __rest(message, ["channelPublicId", "childCount", "creatorPublicId", "mentionedUsers", "messageFeedId", "myReactions", "reactionCount", "reactions", "referenceId", "segment", "messageId"]);
+    const { readCount, deliveredCount } = getReadCount(message, marker);
+    let cache;
+    if (referenceId) {
+        cache = pullFromCache(['message', 'get', referenceId]);
+    }
+    if (!cache) {
+        cache = pullFromCache(['message', 'get', messageId]);
+    }
+    const out = Object.assign(Object.assign({}, rest), { messageId, channelId: channelPublicId, channelSegment: segment, childrenNumber: childCount, creatorId: creatorPublicId, reactions: reactions !== null && reactions !== void 0 ? reactions : {}, reactionsCount: reactionCount, subChannelId: messageFeedId, uniqueId: cache ? cache.data.uniqueId : messageId, readCount,
+        deliveredCount });
+    if (mentionedUsers) {
+        out.mentionees = mentionedUsers.map(mention => {
+            if (mention.type === 'channel') {
+                return mention;
+            }
+            return { type: 'user', userIds: mention.userPublicIds };
+        });
+    }
+    if (myReactions) {
+        // http response
+        out.myReactions = myReactions;
+    }
+    else {
+        // mqtt event
+        prepareMessagePayloadForCache(out);
+    }
+    return out;
+}
+function updateMessageMarker(message, marker) {
+    const { readCount, deliveredCount } = getReadCount(message, marker);
+    return Object.assign(Object.assign({}, message), { readCount,
+        deliveredCount, updatedAt: new Date().toISOString() });
+}
+const prepareMessagePayload = async (payload) => {
+    // make a fetch marker to prepare it for merging with the raw message payload.
+    let markers = [];
+    const markerIds = payload.messages.map(({ messageId }) => messageId);
+    if (markerIds.length > 0)
+        // from the spec, allow marker fetch to fail
+        try {
+            ({ data: markers } = await getMessageMarkers(markerIds));
+        }
+        catch (e) {
+            // empty block
+        }
+    return Object.assign(Object.assign({}, payload), { messages: payload.messages.map(message => {
+            const marker = markers === null || markers === void 0 ? void 0 : markers.find(({ contentId }) => contentId === message.messageId);
+            return convertFromRaw$2(message, marker);
+        }) });
+};
+function convertParams(_a) {
+    var { subChannelId, mentionees } = _a, rest = __rest(_a, ["subChannelId", "mentionees"]);
+    return Object.assign({ messageFeedId: subChannelId, mentionedUsers: mentionees }, rest);
+}
+function convertQueryParams$1(_a) {
+    var { page, sortBy, subChannelId, tags, includeDeleted } = _a, rest = __rest(_a, ["page", "sortBy", "subChannelId", "tags", "includeDeleted"]);
+    const out = Object.assign(Object.assign({}, rest), { messageFeedId: subChannelId, isDeleted: includeDeleted === false ? false : undefined, options: { token: toToken(page || { limit: 10 }, 'afterbeforeraw') } });
+    if (sortBy !== undefined) {
+        out.options.sortBy = sortBy;
+    }
+    if (tags) {
+        out.includeTags = tags;
+    }
+    return out;
+}
+
+/**
+ * ```js
+ * import { onMessageCreated } from '@amityco/ts-sdk'
+ * const dispose = onMessageCreated(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @param local Trigger when an event occurs from a local event or not
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageCreated = (callback, local = true) => {
+    const client = getActiveClient();
+    const filter = async (rawPayload) => {
+        const payload = await prepareMessagePayload(rawPayload);
+        const message = payload.messages[0];
+        ingestInCache(payload);
+        callback(message);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'message/onMessageCreated', 'message.created', filter),
+    ];
+    if (local) {
+        createEventSubscriber(client, 'message/onMessageCreated', 'local.message.created', payload => callback(payload.messages[0]));
+    }
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { onMessageUpdated } from '@amityco/ts-sdk'
+ * const dispose = onMessageUpdated(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageUpdated = (callback) => {
+    const client = getActiveClient();
+    const filter = async (rawPayload) => {
+        const payload = await prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    const messageMarkerChangeHandler = async (rawPayload) => {
+        var _a;
+        const marker = rawPayload.contentMarkers[0];
+        const cacheKey = ['message', 'get', marker.contentId];
+        const message = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!message)
+            return;
+        const updated = updateMessageMarker(message, marker);
+        upsertInCache(cacheKey, updated);
+        callback(updated);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'onMessageUpdated', 'message.updated', filter),
+        createEventSubscriber(client, 'onMessageUpdated', 'local.message.updated', payload => callback(payload.messages[0])),
+        createEventSubscriber(client, 'onMessageUpdated', 'local.messageMarker.fetched', messageMarkerChangeHandler),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { onMessageDeleted } from '@amityco/ts-sdk'
+ * const dispose = onMessageDeleted(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} was deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageDeleted = (callback) => {
+    const client = getActiveClient();
+    const filter = async (rawPayload) => {
+        const payload = await prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'message/onMessageDeleted', 'message.deleted', filter),
+        createEventSubscriber(client, 'local.message.deleted', 'local.message.deleted', payload => callback(payload.messages[0])),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { onMessageFlagged } from '@amityco/ts-sdk'
+ * const dispose = onMessageFlagged(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Message} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageFlagged = (callback) => {
+    const client = getActiveClient();
+    const filter = async (rawPayload) => {
+        const payload = await prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'onMessageFlagged', 'message.flagged', filter);
+};
+
+/**
+ * ```js
+ * import { onMessageUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onMessageUnflagged(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Message}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageUnflagged = (callback) => {
+    const client = getActiveClient();
+    const filter = async (rawPayload) => {
+        const payload = await prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'onMessageUnflagged', 'message.unflagged', filter);
+};
+
+/**
+ * ```js
+ * import { onMessageFlagCleared } from '@amityco/ts-sdk'
+ * const dispose = onMessageFlagCleared(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when flags have been cleared for a {@link Amity.Message}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageFlagCleared = (callback) => {
+    const client = getActiveClient();
+    const filter = async (rawPayload) => {
+        const payload = await prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'onMessageFlagCleared', 'message.flagCleared', filter);
+};
+
+/**
+ * ```js
+ * import { onMessageReactionAdded } from '@amityco/ts-sdk';
+ *
+ * const unsubscribe = onMessageReactionAdded(message => {
+ *   // ...
+ * });
+ * ```
+ *
+ * Fired when a {@link Amity.Message} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onMessageReactionAdded = (callback) => {
+    const client = getActiveClient();
+    const filter = async (rawPayload) => {
+        const payload = await prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'onMessageReactionAdded', 'message.reactionAdded', filter);
+};
+
+/**
+ * ```js
+ * import { onMessageReactionRemoved } from '@amityco/ts-sdk';
+ *
+ * const unsubscribe = onMessageReactionRemoved(message => {
+ *   // ...
+ * });
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Message}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onMessageReactionRemoved = (callback) => {
+    const client = getActiveClient();
+    const filter = async (rawPayload) => {
+        const payload = await prepareMessagePayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'onMessageReactionRemoved', 'message.reactionRemoved', 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', 'local.message.fetched', filter);
+};
+
+const MARKER_INCLUDED_SUB_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
+/**
+ * Filter sub channel by type. Only conversation, community and broadcast type are included.
+ */
+const isUnreadCountSupport$1 = ({ channelType }) => MARKER_INCLUDED_SUB_CHANNEL_TYPE.includes(channelType);
+function getUnreadCount$1(channelId, subChannelId, marker) {
+    var _a;
+    // Look for `unreadCount` in the marker param first
+    if (marker) {
+        return marker.unreadCount;
+    }
+    const key = {
+        entityId: channelId,
+        feedId: subChannelId,
+        userId: getActiveUser()._id,
+    };
+    // If the marker param is not set, look in the cache
+    const cachedMarker = (_a = pullFromCache([
+        'subChannelMarker',
+        'get',
+        getResolver('subChannelMarker')(key),
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (cachedMarker) {
+        return cachedMarker.unreadCount;
+    }
+    // and if not found in cache use default value `0`
+    return 0;
+}
+function convertFromRaw$1(_a, marker) {
+    var { channelId, channelPublicId, channelType, childCount, creatorId, creatorPublicId, lastMessageId, lastMessageTimestamp, messageFeedId, name } = _a, rest = __rest(_a, ["channelId", "channelPublicId", "channelType", "childCount", "creatorId", "creatorPublicId", "lastMessageId", "lastMessageTimestamp", "messageFeedId", "name"]);
+    return Object.assign(Object.assign({}, rest), { channelId: channelPublicId, creatorId: creatorPublicId, displayName: name, lastActivity: lastMessageTimestamp, latestMessageId: lastMessageId, messageCount: childCount, subChannelId: messageFeedId, isUnreadCountSupport: isUnreadCountSupport$1({ channelType }), unreadCount: getUnreadCount$1(channelId, messageFeedId, marker) });
+}
+function updateSubChannelMarker(subChannel, marker) {
+    return Object.assign(Object.assign({}, subChannel), { unreadCount: getUnreadCount$1(subChannel.channelId, subChannel.subChannelId, marker), updatedAt: new Date().toISOString() });
+}
+const prepareSubChannelPayload = async (rawPayload) => {
+    // make a fetch marker to prepare it for merging with the raw channel payload.
+    let markers = [];
+    const markerIds = rawPayload.messageFeeds
+        .filter(isUnreadCountSupport$1)
+        .map(({ messageFeedId }) => messageFeedId);
+    if (markerIds.length > 0)
+        // from the spec, allow marker fetch to fail
+        try {
+            ({ data: markers } = await getSubChannelMarkers(markerIds));
+        }
+        catch (e) {
+            // empty block
+        }
+    // attach marker to sub channel
+    const messageFeeds = rawPayload.messageFeeds.map(messageFeed => {
+        const marker = markers === null || markers === void 0 ? void 0 : markers.find(({ feedId }) => feedId === messageFeed.messageFeedId);
+        return convertFromRaw$1(messageFeed, marker);
+    });
+    return Object.assign(Object.assign({}, rawPayload), { messageFeeds });
+};
+function convertQueryParams(_a) {
+    var { excludeDefaultSubChannel } = _a, rest = __rest(_a, ["excludeDefaultSubChannel"]);
+    const out = Object.assign({}, rest);
+    if (excludeDefaultSubChannel !== undefined) {
+        out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
+    }
+    return out;
+}
+
+/**
+ * ```js
+ * import { SubChannel } from '@amityco/ts-sdk'
+ * const success = await SubChannel('foo')
+ * ```
+ *
+ * Mark all messages as read and start reading message inside channel
+ *
+ * @param messageFeedId - The sub channel ID to start reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+const startReadingAPI = async (messageFeedId) => {
+    const client = getActiveClient();
+    client.log('channel/startReadingAPI', messageFeedId);
+    const { data: payload } = await client.http.post(`/api/v1/markers/message-feeds/${messageFeedId}/start-reading`);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(payload, { cachedAt });
+    return true;
+};
+
+/**
+ * ```js
+ * import { stopReading } from '@amityco/ts-sdk'
+ * const success = await stopReading('foo')
+ * ```
+ *
+ * Mark all messages as read and stop reading message inside channel
+ *
+ * @param messageFeedId - The sub channel ID to stop reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+const stopReadingAPI = async (messageFeedId) => {
+    const client = getActiveClient();
+    client.log('channel/stopReadingAPI', messageFeedId);
+    const { data: payload } = await client.http.post(`/api/v1/markers/message-feeds/${messageFeedId}/stop-reading`);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(payload, { cachedAt });
+    return true;
+};
+
+let disposers$1 = [];
+const isReadingMap = {};
+const updateReadToSegment = (message) => {
+    var _a;
+    if (!isReadingMap[message.subChannelId])
+        return;
+    const client = getActiveClient();
+    if (!client.cache)
+        return;
+    const key = {
+        entityId: message.channelId,
+        feedId: message.subChannelId,
+        userId: getActiveUser()._id,
+    };
+    const currentValue = (_a = pullFromCache([
+        'subChannelMarker',
+        'get',
+        getResolver('subChannelMarker')(key),
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (!currentValue)
+        return;
+    const userFeedMarkers = [Object.assign(Object.assign({}, currentValue), { readToSegment: message.channelSegment })];
+    fireEvent('local.subChannelMarker.updated', { userFeedMarkers });
+};
+/**
+ * the event callback when app is back to online
+ */
+const onOnline$1 = () => {
+    const callback = () => {
+        // Start reading the reading subChannel again when resume from offline state
+        Object.entries(isReadingMap).forEach(([subChannelId, isReading]) => {
+            if (isReading)
+                startReadingAPI(subChannelId);
+        });
+    };
+    window.addEventListener('online', callback);
+    return () => window.removeEventListener('online', callback);
+};
+const registerEventListeners$1 = () => {
+    disposers$1.push(onOnline$1(), onMessageCreated(updateReadToSegment));
+};
+const unRegisterEventListeners$1 = () => {
+    disposers$1.forEach(fn => fn());
+    disposers$1 = [];
+};
+/* begin_public_function
+  id: channel.start_reading
+*/
+/**
+ * ```js
+ * import { startReading } from '@amityco/ts-sdk'
+ * const success = await startReading('foo')
+ * ```
+ *
+ * Set local reading state of channel to `true` and then call mark all
+ * messages as read API.
+ *
+ * @param subChannelId - The sub channel ID to start reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ */
+const startReading = (subChannelId) => {
+    isReadingMap[subChannelId] = true;
+    if (disposers$1.length === 0) {
+        registerEventListeners$1();
+    }
+    return startReadingAPI(subChannelId);
+};
+/* end_public_function */
+/* begin_public_function
+  id: channel.stop_reading
+*/
+/**
+ * ```js
+ * import { stopReading } from '@amityco/ts-sdk'
+ * const success = await stopReading('foo')
+ * ```
+ *
+ * Set local reading state of channel to `false` and then call mark all
+ * messages as unread API.
+ *
+ * @param subChannelId - The sub channel ID to stop reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ */
+const stopReading = (subChannelId) => {
+    isReadingMap[subChannelId] = false;
+    unRegisterEventListeners$1();
+    return stopReadingAPI(subChannelId);
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { onChannelSubCreated } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelCreated(subChannel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.SubChannel} have been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onSubChannelCreated = (callback) => {
+    const client = getActiveClient();
+    const filter = async (rawPayload) => {
+        const payload = await prepareSubChannelPayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messageFeeds[0]);
+    };
+    return createEventSubscriber(client, 'onSubChannelCreated', 'message-feed.created', filter);
+};
+
+/**
+ * ```js
+ * import { onSubChannelUpdated } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelUpdated(subChannel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.SubChannel} have been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onSubChannelUpdated = (callback) => {
+    const client = getActiveClient();
+    const subChannelChangeHandler = async (rawPayload) => {
+        const payload = await prepareSubChannelPayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messageFeeds[0]);
+    };
+    const subChannelMarkerChangeHandler = async (rawPayload) => {
+        var _a;
+        const marker = rawPayload.userFeedMarkers[0];
+        const cacheKey = ['subChannel', 'get', marker.feedId];
+        const subChannel = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!subChannel)
+            return;
+        const updated = updateSubChannelMarker(subChannel, marker);
+        upsertInCache(cacheKey, updated);
+        callback(updated);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'onSubChannelUpdated', 'message-feed.updated', subChannelChangeHandler),
+        createEventSubscriber(client, 'onSubChannelUpdated', 'local.subChannelMarker.fetched', subChannelMarkerChangeHandler),
+        createEventSubscriber(client, 'onSubChannelUpdated', 'local.subChannelMarker.updated', subChannelMarkerChangeHandler),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { onSubChannelDeleted } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelDeleted(subChannel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.SubChannel} have been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onSubChannelDeleted = (callback) => {
+    const client = getActiveClient();
+    const filter = async (rawPayload) => {
+        const payload = await prepareSubChannelPayload(rawPayload);
+        ingestInCache(payload);
+        callback(payload.messageFeeds[0]);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'onSubChannelDeleted', 'message-feed.deleted', filter),
+        createEventSubscriber(client, 'local.message-feed.deleted', 'local.message-feed.deleted', payload => callback(payload.messageFeeds[0])),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+const FORCE_SYNC_INTERVAL_TIME = 8000;
+const SYNC_TRIGGER_INTERVAL_TIME = 2000;
+let clearSyncTrigger;
+let disposers = [];
+let isWaitingForResponse = false;
+/**
+ * list of conditions that make timer still trigger the syncing process.
+ * If it's empty, it means sync is stopped.
+ * if it's not empty, sync will resume.
+ */
+let events = [];
+/**
+ * get current marker sync event list
+ * @private
+ */
+const getMarkerSyncEvents = () => events;
+/**
+ * set marker sync events
+ * @private
+ */
+const setMarkerSyncEvents = (newEvents) => {
+    events = newEvents;
+};
+/**
+ * push new event to marker sync events
+ * @private
+ */
+const pushMarkerSyncEvent = (event) => events.push(event);
+/**
+ * interval task
+ * @private
+ */
+const markerSyncTrigger = async (markerSync) => {
+    if (isWaitingForResponse) {
+        // waiting for the response no need to make another API call
+        return;
+    }
+    if (events.length === 0) {
+        // no event that require to call marker sync API
+        return;
+    }
+    isWaitingForResponse = true;
+    // any past events are considered processed here.
+    // however during waiting for the response, RTE could add the new message event;
+    // which will make the engine trigger another call next round.
+    events = [];
+    const response = await markerSync();
+    if (response.hasMore) {
+        events.push("has_more" /* Amity.MarkerSyncEvent.HAS_MORE */);
+    }
+    // eslint-disable-next-line require-atomic-updates
+    isWaitingForResponse = false;
+};
+/**
+ * the event callback when app is back to online
+ */
+const onOnline = () => {
+    // should add RESUME to the event to trigger marker syncing again
+    const callback = () => events.push("resume" /* Amity.MarkerSyncEvent.RESUME */);
+    window.addEventListener('online', callback);
+    return () => window.removeEventListener('online', callback);
+};
+const setIntervalTask = (handler, timeout) => {
+    const timer = setInterval(handler, timeout);
+    return () => clearInterval(timer);
+};
+const registerEventListeners = () => {
+    // based on the tech spec design, we designed a fetch marker in case of these events
+    // - new message
+    // - create channel
+    // - remove channel
+    // - app going to online again after offline
+    disposers.push(onOnline(), onMessageCreated(message => {
+        // only conversation, community and broadcast types can sync
+        if (isUnreadCountSupport$1(message))
+            events.push("new message" /* Amity.MarkerSyncEvent.NEW_MESSAGE */);
+    }, 
+    // only trigger sync from remote events to prevent an unread count equal `-1`
+    // when an optimistic message creation is performed.
+    false), onSubChannelCreated(() => events.push("subchannel is created" /* Amity.MarkerSyncEvent.SUB_CHANNEL_CREATED */)), onSubChannelDeleted(() => events.push("subchannel is deleted" /* Amity.MarkerSyncEvent.SUBCHANNEL_IS_DELETED */)), 
+    // In real-world use, we've encountered some cases where BE returns empty result
+    // even if a marker changes in the database, causing the SDK to mistakenly believe that
+    // no changes have been made in the database and end the sync prematurely.
+    // Did miss update the unread count
+    //
+    // We found that some time BE loads were too high, causing the calculation
+    // marker not to finish within the sync time, so it returned an empty value.
+    //
+    // Therefore, solve this problem by creating a second interval loop that
+    // runs every 8 seconds regardless of whether an event occurs or not so that
+    // the unread count is always updated in case of an error like the above.
+    setIntervalTask(() => events.push("force sync" /* Amity.MarkerSyncEvent.FORCE_SYNC */), FORCE_SYNC_INTERVAL_TIME));
+};
+const unRegisterEventListeners = () => {
+    disposers.forEach(fn => fn());
+    disposers = [];
+};
+/**
+ ```js
+ * import { startUnreadSync } from '@amityco/ts-sdk'
+ * startUnreadSync()
+ * ```
+ *
+ * start syncing to keep feed markers, channel markers and user makers cache
+ * update to the server.
+ *
+ * @category Marker API
+ */
+const startUnreadSync = () => {
+    pushMarkerSyncEvent("start syncing" /* Amity.MarkerSyncEvent.START_SYNCING */);
+    if (!clearSyncTrigger) {
+        // it is possible to repeatedly call the API when multiple events occur at the same time.
+        // This is very burdensome to the BE Server, so we have an interval loop for
+        // grouping every event that occurs within 2 seconds into a single API call.
+        //
+        // interval loop is also useful for fetching large results. Because if the result
+        // is more than 20 records, the API will split the result into multiple pages
+        // and the SDK will need to fetch it repeatedly until all the results are available.
+        // So we need an interval loop for repeat fetch.
+        clearSyncTrigger = setIntervalTask(() => markerSyncTrigger(markerSync), SYNC_TRIGGER_INTERVAL_TIME);
+    }
+    registerEventListeners();
+};
+/**
+ ```js
+ * import { stopUnreadSyncing } from '@amityco/ts-sdk'
+ * stopUnreadSyncing()
+ * ```
+ *
+ * stop unread syncing
+ *
+ * @category Marker API
+ */
+const stopUnreadSyncing = () => {
+    clearSyncTrigger === null || clearSyncTrigger === void 0 ? void 0 : clearSyncTrigger();
+    clearSyncTrigger = undefined;
+    setMarkerSyncEvents([]);
+    unRegisterEventListeners();
+};
+
+/**
+ * ```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);
+};
+
+/* begin_public_function
+  id: user.get
+*/
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk'
+ * const { data: user } = await getUser('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category User API
+ * @async
+ */
+const getUser = async (userId, isLive = false) => {
+    const client = getActiveClient();
+    client.log('user/getUser', 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,
+    };
+};
+/* end_public_function */
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk'
+ * const { data: user } = getUser.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object from cache
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category User API
+ */
+getUser.locally = (userId) => {
+    const client = getActiveClient();
+    client.log('user/getUser.locally', userId);
+    return client.cache && pullFromCache(['user', 'get', userId]);
+};
+
+/* begin_public_function
+  id: user.get_by_ids
+*/
+/**
+ * ```js
+ * import { getUsers } from '@amityco/ts-sdk'
+ * const { data: users } = await getUsers(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.User} objects
+ *
+ * @param userIds the IDs of the {@link Amity.User} to fetch
+ * @returns the associated collection of {@link Amity.User} objects
+ *
+ * @category User API
+ * @async
+ */
+const getUsers = async (userIds) => {
+    const client = getActiveClient();
+    client.log('user/getUsers', userIds);
+    const encodedUserIds = userIds.map(userId => encodeURIComponent(userId));
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/users/list`, {
+        params: { userIds: encodedUserIds },
+    });
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    fireEvent('user.fetched', data);
+    return {
+        data: data.users,
+        cachedAt,
+    };
+};
+/**
+ * ```js
+ * import { getUsers } from '@amityco/ts-sdk'
+ * const { data: users } = getUsers.locally!(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.User} objects from cache
+ *
+ * @param userIds the IDs of the {@link Amity.User} to fetch
+ * @returns the associated collection of {@link Amity.User} objects
+ *
+ * @category User API
+ */
+getUsers.locally = (userIds) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('user/getUsers.locally', userIds);
+    if (!client.cache)
+        return;
+    const cached = userIds
+        .map(userId => pullFromCache(['user', 'get', userId]))
+        .filter(Boolean);
+    const users = cached.map(({ data }) => data);
+    const oldest = (_a = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _a === void 0 ? void 0 : _a[0];
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) < userIds.length)
+        return;
+    return {
+        data: users,
+        cachedAt: oldest.cachedAt,
+    };
+};
+
+/* begin_public_function
+  id: user.query, user.search
+*/
+/**
+ * ```js
+ * import { queryUsers } from '@amityco/ts-sdk'
+ * const { data: users, prevPage, nextPage } = await queryUsers({ displayName: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.User} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.User} objects
+ *
+ * @category User API
+ * @async
+ */
+const queryUsers = async (query = {}) => {
+    const client = getActiveClient();
+    client.log('user/queryUsers', query);
+    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: {
+                token: toToken(page, 'skiplimit'),
+            } }),
+    });
+    // unpacking
+    const { paging } = data, payload = __rest(data, ["paging"]);
+    const { users } = payload;
+    const cachedAt = client.cache && Date.now();
+    if (client.cache) {
+        ingestInCache(payload, { cachedAt });
+        /*
+         * 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 };
+};
+/* end_public_function */
+/**
+ * ```js
+ * import { queryUsers } from '@amityco/ts-sdk'
+ * const { data: users } = queryUsers.locally({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.User} objects from cache
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.User} objects
+ *
+ * @category User API
+ */
+queryUsers.locally = (query = {}) => {
+    var _a, _b, _c;
+    const client = getActiveClient();
+    client.log('user/queryUsers.locally', query);
+    if (!client.cache)
+        return;
+    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);
+    return users.length > 0 && users.length === ((_c = data === null || data === void 0 ? void 0 : data.users) === null || _c === void 0 ? void 0 : _c.length)
+        ? { data: users, cachedAt, prevPage, nextPage }
+        : undefined;
+};
+
+/* begin_public_function
+  id: client.update_user
+*/
+/**
+ * ```js
+ * import { updateUser } from '@amityco/ts-sdk'
+ * const updated = await updateUser(userId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.User}
+ *
+ * @param userId The ID of the {@link Amity.User} to update
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.User} object
+ *
+ * @category User API
+ * @async
+ */
+const updateUser = async (userId, patch) => {
+    const client = getActiveClient();
+    client.log('user/updateUser', userId, patch);
+    // API-FIX: Endpoint is malformed, userId should be a url param.
+    /*
+      const { data } = await client.http.put<Amity.Response<UserPayload>>(
+        `/api/v3/users/${userId}`, patch,
+      )
+    */
+    const { data } = await client.http.put(`/api/v3/users/`, Object.assign(Object.assign({ userId }, patch), { createNewUserWhenNotFound: false }));
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    const { users } = data;
+    fireEvent('user.updated', data);
+    return {
+        data: users.find(user => user.userId === userId),
+        cachedAt,
+    };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { onUserUpdated } from '@amityco/ts-sdk'
+ * const dispose = onUserUpdated(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+const onUserUpdated = (callback) => createUserEventSubscriber('user.updated', callback);
+
+/**
+ * ```js
+ * import { onUserFlagged } from '@amityco/ts-sdk'
+ * const dispose = onUserFlagged(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+const onUserFlagged = (callback) => createUserEventSubscriber('user.flagged', callback);
+
+/**
+ * ```js
+ * import { onUserUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onUserUnflagged(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.User}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+const onUserUnflagged = (callback) => createUserEventSubscriber('user.unflagged', callback);
+
+/**
+ * ```js
+ * import { onUserFlagCleared } from '@amityco/ts-sdk'
+ * const dispose = onUserFlagCleared(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when flags have been cleared for a {@link Amity.User}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+const onUserFlagCleared = (callback) => createUserEventSubscriber('user.flagCleared', callback);
+
+/**
+ * ```js
+ * import { onUserFetched } from '@amityco/ts-sdk'
+ * const dispose = onUserFetched(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+const onUserFetched = (callback) => createUserEventSubscriber('user.fetched', callback);
+
+/**
  * ```js
  * import { liveUser } from '@amityco/ts-sdk';
  *
@@ -22080,139 +23273,45 @@ const getRole = async (roleId) => {
         cachedAt,
     };
 };
-/**
- * ```js
- * import { getRole } from '@amityco/ts-sdk'
- * const role = getRole.locally('foobar')
- * ```
- *
- * Fetches a {@link Amity.Role} object from cache
- *
- * @param roleId the ID of the {@link Amity.Role} to fetch
- * @returns the associated {@link Amity.Role} object
- *
- * @category Role API
- */
-getRole.locally = (roleId) => {
-    const client = getActiveClient();
-    client.log('role/getRole.locally', roleId);
-    if (!client.cache)
-        return;
-    const cached = pullFromCache(['role', 'get', roleId]);
-    if (!cached)
-        return;
-    return {
-        data: cached.data,
-        cachedAt: cached.cachedAt,
-    };
-};
-
-/** @hidden */
-const dispatchReactable = (referenceType, model) => {
-    if (referenceType === 'message')
-        // @ts-ignore: refactor later
-        fireEvent('local.message.updated', { messages: [model] });
-    else if (referenceType === 'post')
-        // @ts-ignore: refactor later
-        fireEvent('post.updated', { posts: [model] });
-    else if (referenceType === 'comment')
-        // @ts-ignore: refactor later
-        fireEvent('comment.updated', { comments: [model] });
-};
-
-/** @hidden */
-/*
- * @param message payload from http request without myReactions
- * add myReactions to http response if the event was a reaction event
- */
-const prepareMessagePayloadForCache = (payload) => {
-    const client = getActiveClient();
-    const cached = pullFromCache(['message', 'get', payload.messageId]);
-    // '[]' in cases where the new reaction is the first one
-    const myReactions = (cached === null || cached === void 0 ? void 0 : cached.data.myReactions) || [];
-    // add myReactions to the payload
-    Object.assign(payload, { myReactions });
-    // check if there are any updates to the reactions
-    const latestReaction = payload === null || payload === void 0 ? void 0 : payload.latestReaction;
-    const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
-    if (!isLatestReactionMine) {
-        return;
-    }
-    // new reaction added
-    if (latestReaction.eventName === 'add' && !myReactions.includes(latestReaction.reactionName)) {
-        Object.assign(payload, {
-            myReactions: [...myReactions, latestReaction.reactionName],
-        });
-    }
-    // existing reaction removed
-    if (latestReaction.eventName === 'remove' && myReactions.includes(latestReaction.reactionName)) {
-        Object.assign(payload, {
-            myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
-        });
-    }
-};
-
-function convertFromRaw$2(_a) {
-    var { channelPublicId, childCount, creatorPublicId, mentionedUsers, messageFeedId, myReactions, reactionCount, reactions, referenceId, segment } = _a, rest = __rest(_a, ["channelPublicId", "childCount", "creatorPublicId", "mentionedUsers", "messageFeedId", "myReactions", "reactionCount", "reactions", "referenceId", "segment"]);
-    let cache;
-    if (referenceId) {
-        try {
-            cache = pullFromCache(['message', 'get', referenceId]);
-            // eslint-disable-next-line no-empty
-        }
-        catch (_b) { }
-    }
-    if (!cache) {
-        try {
-            cache = pullFromCache(['message', 'get', rest.messageId]);
-            // eslint-disable-next-line no-empty
-        }
-        catch (_c) { }
-    }
-    const out = Object.assign(Object.assign({}, rest), { channelId: channelPublicId, channelSegment: segment, childrenNumber: childCount, creatorId: creatorPublicId, reactions: reactions !== null && reactions !== void 0 ? reactions : {}, reactionsCount: reactionCount, subChannelId: messageFeedId, uniqueId: cache ? cache.data.uniqueId : rest.messageId });
-    if (mentionedUsers) {
-        out.mentionees = mentionedUsers.map(mention => {
-            if (mention.type === 'channel') {
-                return mention;
-            }
-            return { type: 'user', userIds: mention.userPublicIds };
-        });
-    }
-    if (myReactions) {
-        // http response
-        out.myReactions = myReactions;
-    }
-    else {
-        // mqtt event
-        try {
-            prepareMessagePayloadForCache(out);
-            // eslint-disable-next-line no-empty
-        }
-        catch (_d) { }
-    }
-    return out;
-}
-const prepareMessagePayload = (payload) => {
-    return Object.assign(Object.assign({}, payload), { messages: payload.messages.map(convertFromRaw$2) });
-};
-const convertResponseFromRaw = (response) => {
-    return Object.assign(Object.assign({}, response), { data: Object.assign(Object.assign({}, response.data), { messages: response.data.messages.map(convertFromRaw$2) }) });
-};
-function convertParams(_a) {
-    var { subChannelId, mentionees } = _a, rest = __rest(_a, ["subChannelId", "mentionees"]);
-    return Object.assign({ messageFeedId: subChannelId, mentionedUsers: mentionees }, rest);
-}
-function convertQueryParams$1(_a) {
-    var { page, sortBy, subChannelId, tags, includeDeleted } = _a, rest = __rest(_a, ["page", "sortBy", "subChannelId", "tags", "includeDeleted"]);
-    const out = Object.assign(Object.assign({}, rest), { messageFeedId: subChannelId, isDeleted: includeDeleted === false ? false : undefined, options: { token: toToken(page || { limit: 10 }, 'afterbeforeraw') } });
-    if (sortBy !== undefined) {
-        out.options.sortBy = sortBy;
-    }
-    if (tags) {
-        out.includeTags = tags;
-    }
-    return out;
-}
+/**
+ * ```js
+ * import { getRole } from '@amityco/ts-sdk'
+ * const role = getRole.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Role} object from cache
+ *
+ * @param roleId the ID of the {@link Amity.Role} to fetch
+ * @returns the associated {@link Amity.Role} object
+ *
+ * @category Role API
+ */
+getRole.locally = (roleId) => {
+    const client = getActiveClient();
+    client.log('role/getRole.locally', roleId);
+    if (!client.cache)
+        return;
+    const cached = pullFromCache(['role', 'get', roleId]);
+    if (!cached)
+        return;
+    return {
+        data: cached.data,
+        cachedAt: cached.cachedAt,
+    };
+};
+
+/** @hidden */
+const dispatchReactable = (referenceType, model) => {
+    if (referenceType === 'message')
+        // @ts-ignore: refactor later
+        fireEvent('local.message.updated', { messages: [model] });
+    else if (referenceType === 'post')
+        // @ts-ignore: refactor later
+        fireEvent('post.updated', { posts: [model] });
+    else if (referenceType === 'comment')
+        // @ts-ignore: refactor later
+        fireEvent('comment.updated', { comments: [model] });
+};
 
 /* begin_public_function
   id: message.get
@@ -22241,10 +23340,8 @@ const getMessage = async (messageId, isLive = false) => {
     let data;
     try {
         // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http
-            .get(`/api/v5/messages/${encodeURIComponent(messageId)}`)
-            .then(convertResponseFromRaw);
-        data = response.data;
+        const { data: payload } = await client.http.get(`/api/v5/messages/${encodeURIComponent(messageId)}`);
+        data = await prepareMessagePayload(payload);
     }
     catch (error) {
         if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
@@ -22307,11 +23404,10 @@ getMessage.locally = (messageId) => {
 const getMessages = async (messageIds) => {
     const client = getActiveClient();
     client.log('message/getMessages', messageIds);
-    const { data } = await client.http
-        .get(`/api/v5/messages/list`, {
+    const { data: payload } = await client.http.get(`/api/v5/messages/list`, {
         params: { messageIds: messageIds.map(encodeURIComponent) },
-    })
-        .then(convertResponseFromRaw);
+    });
+    const data = await prepareMessagePayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -22379,12 +23475,11 @@ const queryMessages = async (query) => {
     // API-FIX: backend should answer Amity.Response (2)
     // API-FIX: pagination should not be indexed on channelSegment (3)
     // const { data } = await client.http.get<Amity.Response<Amity.Paged<Amity.MessagePayload>>>(
-    const response = await client.http
-        .get(`/api/v5/messages`, { params })
-        .then(convertResponseFromRaw);
+    const { data: queryPayload } = await client.http.get(`/api/v5/messages`, { params });
     // API-FIX: backend should answer Amity.Response (2)
     // const { paging, messages } = unwrapPayload(data)
-    const _a = response.data, { paging } = _a, data = __rest(_a, ["paging"]);
+    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
+    const data = await prepareMessagePayload(payload);
     const { messages } = data;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
@@ -22469,7 +23564,7 @@ const createMessage = async (bundle) => {
     const referenceId = bundle.referenceId || uniqueId || getLocalId();
     uniqueId = undefined;
     const { data: payload } = await client.http.post('/api/v5/messages', Object.assign(Object.assign({}, convertParams(bundle)), { referenceId }));
-    const data = prepareMessagePayload(payload);
+    const data = await prepareMessagePayload(payload);
     const { messages } = data;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
@@ -22561,9 +23656,8 @@ createMessage.optimistically = (_a) => {
 const updateMessage = async (messageId, patch) => {
     const client = getActiveClient();
     client.log('message/updateMessage', patch);
-    const { data } = await client.http
-        .put(`/api/v5/messages/${encodeURIComponent(messageId)}`, convertParams(patch))
-        .then(convertResponseFromRaw);
+    const { data: payload } = await client.http.put(`/api/v5/messages/${encodeURIComponent(messageId)}`, convertParams(patch));
+    const data = await prepareMessagePayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -22665,6 +23759,31 @@ deleteMessage.optimistically = (messageId) => {
 };
 /* end_public_function */
 
+/**
+ * ```js
+ * import { markAsDelivered } from '@amityco/ts-sdk'
+ * const success = await markAsDelivered('subChannelId', 'messageId')
+ * ```
+ *
+ * Update `deliveredToSegment` in  {@link Amity.SubChannelMarker}
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} of message
+ * @param messageId the ID of the {@link Amity.Message} to mark delivered
+ * @returns A success boolean if the {@link Amity.SubChannel} was updated
+ *
+ * @category Message API
+ * @async
+ */
+const markAsDelivered = async (subChannelId, messageId) => {
+    const client = getActiveClient();
+    client.log('message/markAsDelivered', subChannelId, messageId);
+    const { data } = await client.http.put(`/api/v1/markers/message-feeds/${subChannelId}/mark-delivering`, { messageId });
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    return true;
+};
+
 /**
  * Attach user object to membership model
  * - If cache is not enabled, set user to undefined ({..., user: undefined})
@@ -24974,9 +26093,9 @@ const onReactionAdded = (referenceType, referenceId, callback) => {
      */
     if (referenceType === 'message') {
         const client = getActiveClient();
-        const filter = (rawPayload) => {
+        const filter = async (rawPayload) => {
             var _a;
-            const payload = prepareMessagePayload(rawPayload);
+            const payload = await prepareMessagePayload(rawPayload);
             const cached = pullFromCache([
                 'message',
                 'get',
@@ -25021,9 +26140,9 @@ const onReactionRemoved = (referenceType, referenceId, callback) => {
     };
     if (referenceType === 'message') {
         const client = getActiveClient();
-        const filter = (rawPayload) => {
+        const filter = async (rawPayload) => {
             var _a;
-            const payload = prepareMessagePayload(rawPayload);
+            const payload = await prepareMessagePayload(rawPayload);
             const cached = pullFromCache([
                 'message',
                 'get',
@@ -25068,8 +26187,8 @@ const onReactorAdded = (referenceType, referenceId, callback) => {
         }
     };
     if (referenceType === 'message') {
-        const filter = (rawPayload) => {
-            const payload = prepareMessagePayload(rawPayload);
+        const filter = async (rawPayload) => {
+            const payload = await prepareMessagePayload(rawPayload);
             if (!payload.messages[0].latestReaction)
                 return;
             const _a = payload.messages[0].latestReaction, { eventName, referenceId, referenceType, userDisplayName } = _a, reactor = __rest(_a, ["eventName", "referenceId", "referenceType", "userDisplayName"]);
@@ -25130,8 +26249,8 @@ const onReactorRemoved = (referenceType, referenceId, callback) => {
         }
     };
     if (referenceType === 'message') {
-        const filter = (rawPayload) => {
-            const payload = prepareMessagePayload(rawPayload);
+        const filter = async (rawPayload) => {
+            const payload = await prepareMessagePayload(rawPayload);
             if (!payload.messages[0].latestReaction)
                 return;
             const _a = payload.messages[0].latestReaction, { eventName, referenceId, referenceType } = _a, reactor = __rest(_a, ["eventName", "referenceId", "referenceType"]);
@@ -25317,7 +26436,8 @@ const createReport = async (referenceType, referenceId) => {
     const { data: payload } = await client.http.post(getAPIUrl());
     if (client.cache) {
         if (referenceType === 'message') {
-            ingestInCache(prepareMessagePayload(payload));
+            const messagePayload = await prepareMessagePayload(payload);
+            ingestInCache(messagePayload);
         }
         else if (referenceType === 'post') {
             ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
@@ -25363,7 +26483,8 @@ const deleteReport = async (referenceType, referenceId) => {
     const { data: payload } = await client.http.delete(getAPIUrl());
     if (client.cache) {
         if (referenceType === 'message') {
-            ingestInCache(prepareMessagePayload(payload));
+            const messagePayload = await prepareMessagePayload(payload);
+            ingestInCache(messagePayload);
         }
         else if (referenceType === 'post') {
             ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
@@ -25410,37 +26531,60 @@ const isReportedByMe = async (referenceType, referenceId) => {
 };
 /* end_public_function */
 
-function convertFromRaw$1(_a, params) {
-    var { _id } = _a, rest = __rest(_a, ["_id"]);
-    return Object.assign(Object.assign(Object.assign({}, rest), params), { defaultSubChannelId: _id });
-}
-function getSegmentParams(rawChannel) {
-    let cached;
-    try {
-        cached = pullFromCache(['channel', 'get', rawChannel.channelId]);
-        // eslint-disable-next-line no-empty
-    }
-    catch (_a) { }
-    if (cached) {
-        return {
-            defaultSubChannelHasUnreadMention: cached.data.defaultSubChannelHasUnreadMention,
-            defaultSubChannelUnreadCount: cached.data.defaultSubChannelUnreadCount,
-            localReadToSegment: cached.data.localReadToSegment,
-            localLastMentionSegment: cached.data.localLastMentionSegment,
-        };
-    }
-    return {
-        defaultSubChannelHasUnreadMention: false,
-        defaultSubChannelUnreadCount: 0,
-        // @ts-ignore
-        localReadToSegment: rawChannel.messageCount > 0 ? rawChannel.messageCount - 1 : 0,
-        localLastMentionSegment: 0,
+const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
+const isUnreadCountSupport = ({ type }) => MARKER_INCLUDED_CHANNEL_TYPE.includes(type);
+const getCachedMarker = (entityId) => {
+    var _a;
+    const key = {
+        entityId,
+        userId: getActiveUser()._id,
     };
+    return (_a = pullFromCache([
+        'channelMarker',
+        'get',
+        getResolver('channelMarker')(key),
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+};
+const getUnreadCount = (channel, marker) => {
+    var _a, _b, _c;
+    if (marker === null || marker === void 0 ? void 0 : marker.isDeleted) {
+        // NOTE: This is a temporary solution to handle the channel marker when the user is forced to
+        // leave the channel because currently backend can't handle this, so every time a user is banned
+        // from a channel or the channel is deleted the channel's unread count will reset to zero
+        return 0;
+    }
+    return (_c = (_a = marker === null || marker === void 0 ? void 0 : marker.unreadCount) !== null && _a !== void 0 ? _a : (_b = getCachedMarker(channel.channelId)) === null || _b === void 0 ? void 0 : _b.unreadCount) !== null && _c !== void 0 ? _c : 0;
+};
+function convertFromRaw(channel, marker) {
+    return Object.assign(Object.assign({}, channel), { isUnreadCountSupport: isUnreadCountSupport(channel), unreadCount: getUnreadCount(channel, marker) });
+}
+function updateChannelMarker(channel, marker) {
+    return Object.assign(Object.assign({}, channel), { unreadCount: getUnreadCount(channel, marker), updatedAt: new Date().toISOString() });
 }
-const prepareChannelPayload = (rawPayload) => {
-    const channels = rawPayload.channels.map(channel => convertFromRaw$1(channel, getSegmentParams(channel)));
+const prepareChannelPayload = async (rawPayload) => {
+    // make a fetch marker to prepare it for merging with the raw channel payload.
+    let markers = [];
+    const markerIds = rawPayload.channels
+        // filter channel by type. Only conversation, community and broadcast type are included.
+        .filter(isUnreadCountSupport)
+        .map(({ channelId }) => channelId);
+    if (markerIds.length > 0)
+        // from the spec, allow marker fetch to fail
+        try {
+            ({ data: markers } = await getChannelMarkers(markerIds));
+        }
+        catch (e) {
+            // empty block
+        }
+    // attach marker to channel
+    const channels = rawPayload.channels.map(channel => {
+        const marker = markers === null || markers === void 0 ? void 0 : markers.find(({ entityId }) => entityId === channel.channelId);
+        return convertFromRaw(channel, marker);
+    });
+    // user marker to channel users
     const channelUsers = withUsers(rawPayload.channelUsers);
-    return Object.assign(Object.assign({}, rawPayload), { channels, channelUsers });
+    return Object.assign(Object.assign({}, rawPayload), { channels,
+        channelUsers });
 };
 
 /* begin_public_function
@@ -25475,7 +26619,7 @@ const queryChannels = async (query) => {
             } }),
     });
     const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
-    const data = prepareChannelPayload(payload);
+    const data = await prepareChannelPayload(payload);
     const { channels } = data;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
@@ -25560,7 +26704,7 @@ const getChannels = async (channelIds) => {
         });
         throw error;
     }
-    const data = prepareChannelPayload(payload);
+    const data = await prepareChannelPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -25625,7 +26769,7 @@ const getChannel = async (channelId) => {
     let data;
     try {
         const { data: payload } = await client.http.get(`/api/v3/channels/${encodeURIComponent(channelId)}`);
-        data = prepareChannelPayload(payload);
+        data = await prepareChannelPayload(payload);
     }
     catch (error) {
         if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
@@ -25697,7 +26841,7 @@ const createChannel = async (bundle) => {
     else {
         payload = await client.http.post('/api/v3/channels', bundle);
     }
-    const data = prepareChannelPayload(payload.data);
+    const data = await prepareChannelPayload(payload.data);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -25731,7 +26875,7 @@ const updateChannel = async (channelId, patch) => {
     const client = getActiveClient();
     client.log('channel/updateChannel', channelId, patch);
     const { data: payload } = await client.http.put(`/api/v3/channels/${encodeURIComponent(channelId)}`, patch);
-    const data = prepareChannelPayload(payload);
+    const data = await prepareChannelPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -25787,7 +26931,7 @@ const joinChannel = async (channelId) => {
     const client = getActiveClient();
     client.log('channel/joinChannel', channelId);
     const { data: payload } = await client.http.post(`/api/v3/channels/${encodeURIComponent(channelId)}/join`);
-    const data = prepareChannelPayload(payload);
+    const data = await prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
     const { channelUsers } = data;
@@ -25816,7 +26960,7 @@ const leaveChannel = async (channelId) => {
     const client = getActiveClient();
     client.log('channel/leaveChannel', channelId);
     const { data: payload } = await client.http.delete(`/api/v3/channels/${encodeURIComponent(channelId)}/leave`);
-    const data = prepareChannelPayload(payload);
+    const data = await prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
     const { channelUsers } = data;
@@ -25851,7 +26995,7 @@ const queryChannelMembers = async (query) => {
             } }),
     });
     const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
-    const preparedPayload = prepareChannelPayload(payload);
+    const preparedPayload = await prepareChannelPayload(payload);
     const { channelUsers } = preparedPayload;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
@@ -25942,7 +27086,7 @@ const addChannelMembers = async (channelId, userIds) => {
      * should fire event for each user that was added
      */
     userIds.forEach(id => fireEvent('channel.membersAdded', Object.assign(Object.assign({}, payload), { channelUsers: payload.channelUsers.filter(u => u.userId === id) })));
-    const data = prepareChannelPayload(payload);
+    const data = await prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
     const { channelUsers } = data;
@@ -25976,7 +27120,7 @@ const removeChannelMembers = async (channelId, userIds) => {
      * should fire event for each user that was removed
      */
     userIds.forEach(id => fireEvent('channel.membersRemoved', Object.assign(Object.assign({}, payload), { channelUsers: payload.channelUsers.filter(u => u.userId === id) })));
-    const data = prepareChannelPayload(payload);
+    const data = await prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
     const { channelUsers } = data;
@@ -26007,7 +27151,7 @@ const addChannelMembersRole = async (channelId, roleId, userIds) => {
     const client = getActiveClient();
     client.log('channel/addChannelMembersRole', channelId, roleId, userIds);
     const { data: payload } = await client.http.post(`/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`, { channelId, role: roleId, userIds });
-    const data = prepareChannelPayload(payload);
+    const data = await prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
     const { channelUsers } = data;
@@ -26038,7 +27182,7 @@ const removeChannelMembersRole = async (channelId, roleId, userIds) => {
     const client = getActiveClient();
     client.log('channel/removeChannelMembersRole', channelId, 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);
+    const data = await prepareChannelPayload(payload);
     if (client.cache)
         ingestInCache(data);
     const { channelUsers } = data;
@@ -26069,7 +27213,7 @@ const banChannelMembers = async (channelId, userIds) => {
     const { data: payload } = await client.http.put(`/api/v3/channels/${channelId}/users/ban`, {
         userIds,
     });
-    const preparedPayload = prepareChannelPayload(payload);
+    const preparedPayload = await prepareChannelPayload(payload);
     const { channelUsers } = preparedPayload;
     const cachedAt = client.cache && Date.now();
     if (client.cache)
@@ -26104,7 +27248,7 @@ const unbanChannelMembers = async (channelId, userIds) => {
     const { data: payload } = await client.http.put(`/api/v3/channels/${encodeURIComponent(channelId)}/users/unban`, {
         userIds,
     });
-    const preparedPayload = prepareChannelPayload(payload);
+    const preparedPayload = await prepareChannelPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(preparedPayload, { cachedAt });
@@ -26116,88 +27260,6 @@ const unbanChannelMembers = async (channelId, userIds) => {
 };
 /* end_public_function */
 
-/* begin_public_function
-  id: channel.start_reading
-*/
-/**
- * ```js
- * import { startReading } from '@amityco/ts-sdk'
- * const success = await startReading('foo')
- * ```
- *
- * Mark all messages as read and start reading message inside channel
- *
- * @param subChannelId - The channel ID to start reading.
- * @param userId - The user ID of channel member.
- * @return A success boolean if the channel reading of the sub channel had begun.
- *
- * @category Message API
- * @async
- */
-const startReading = async (subChannelId, userId = getActiveClient().userId) => {
-    const client = getActiveClient();
-    client.log('message/startReading', { subChannelId });
-    const subChannel = pullFromCache(['subChannel', 'get', subChannelId]);
-    if (!subChannel) {
-        return;
-    }
-    const { channelId } = subChannel.data;
-    const channel = pullFromCache(['channel', 'get', channelId]);
-    if (!channel || channel.data.defaultSubChannelId !== subChannelId) {
-        return;
-    }
-    const update = Object.assign(Object.assign({}, channel.data), { 
-        // @ts-ignore
-        localReading: true, defaultSubChannelUnreadCount: 0, defaultSubChannelHasUnreadMention: false });
-    pushToCache(['channel', 'get', channelId], update);
-    client.emitter.emit('local.channel.updated', { channels: [update] });
-    const result = await synchronousWSCall(client, 'channel.startReading', {
-        channelId,
-    });
-    return !!result;
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: channel.stop_reading
-*/
-/**
- * ```js
- * import { stopReading } from '@amityco/ts-sdk'
- * const success = await stopReading('foo')
- * ```
- *
- * Stop reading message inside channel
- *
- * @param subChannelId - The channel ID to stop reading.
- * @return A success boolean if the sub channel reading was halted.
- *
- * @category Message API
- * @async
- */
-const stopReading = async (subChannelId) => {
-    const client = getActiveClient();
-    client.log('message/stopReading', { subChannelId });
-    const subChannel = pullFromCache(['subChannel', 'get', subChannelId]);
-    if (!subChannel) {
-        return;
-    }
-    const { channelId } = subChannel.data;
-    const channel = pullFromCache(['channel', 'get', channelId]);
-    if (!channel || channel.data.defaultSubChannelId !== subChannelId) {
-        return;
-    }
-    const update = Object.assign(Object.assign({}, channel.data), { 
-        // @ts-ignore
-        localReading: false });
-    pushToCache(['channel', 'get', channelId], update);
-    const result = await synchronousWSCall(client, 'channel.stopReading', {
-        channelId,
-    });
-    return !!result;
-};
-/* end_public_function */
-
 /**
  * ```js
  * import { onChannelCreated } from '@amityco/ts-sdk'
@@ -26206,602 +27268,345 @@ const stopReading = async (subChannelId) => {
  * })
  * ```
  *
- * Fired when any {@link Amity.Channel} have been created
- *
- * @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();
-    const filter = (payload) => {
-        const data = prepareChannelPayload(payload);
-        ingestInCache(data);
-        callback(data.channels[0]);
-    };
-    return createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
-};
-
-/**
- * ```js
- * import { onChannelUpdated } from '@amityco/ts-sdk'
- * const dispose = onChannelUpdated(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} have been updated
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-const onChannelUpdated = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        const data = prepareChannelPayload(payload);
-        ingestInCache(data);
-        callback(data.channels[0]);
-    };
-    const disposers = [
-        createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter),
-        createEventSubscriber(client, 'local.channel.updated', 'local.channel.updated', payload => callback(payload.channels[0])),
-    ];
-    return () => {
-        disposers.forEach(fn => fn());
-    };
-};
-
-/**
- * ```js
- * import { onChannelDeleted } from '@amityco/ts-sdk'
- * const dispose = onChannelDeleted(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} have been deleted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-const onChannelDeleted = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        const data = prepareChannelPayload(payload);
-        ingestInCache(data);
-        callback(data.channels[0]);
-    };
-    return createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
-};
-
-/**
- * ```js
- * import { onChannelJoined } from '@amityco/ts-sdk'
- * const dispose = onChannelJoined((channel, member) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} was joined
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-const onChannelJoined = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        const preparedPayload = prepareChannelPayload(payload);
-        const { channels, channelUsers } = preparedPayload;
-        ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers[0]);
-    };
-    return createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
-};
-
-/**
- * ```js
- * import { onChannelLeft } from '@amityco/ts-sdk'
- * const dispose = onChannelLeft((channel, member) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} was left
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-const onChannelLeft = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        const preparedPayload = prepareChannelPayload(payload);
-        const { channels, channelUsers } = preparedPayload;
-        ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers[0]);
-    };
-    return createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
-};
-
-/**
- * ```js
- * import { onChannelMuted } from '@amityco/ts-sdk'
- * const dispose = onChannelMuted(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} have been muted
+ * Fired when any {@link Amity.Channel} have been created
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Channel Events
  */
-const onChannelMuted = (callback) => {
+const onChannelCreated = (callback) => {
     const client = getActiveClient();
-    const filter = (payload) => {
-        const data = prepareChannelPayload(payload);
+    const filter = async (payload) => {
+        const data = await prepareChannelPayload(payload);
         ingestInCache(data);
         callback(data.channels[0]);
     };
-    return createEventSubscriber(client, 'onChannelMuted', 'channel.setMuted', filter);
+    return createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
 };
 
 /**
  * ```js
- * import { onChannelMemberAdded } from '@amityco/ts-sdk'
- * const dispose = onChannelMemberAdded((channel, member) => {
+ * import { onChannelUpdated } from '@amityco/ts-sdk'
+ * const dispose = onChannelUpdated(channel => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
+ * Fired when any {@link Amity.Channel} have been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Channel Events
  */
-const onChannelMemberAdded = (callback) => {
+const onChannelUpdated = (callback) => {
     const client = getActiveClient();
-    const filter = (payload) => {
-        const preparedPayload = prepareChannelPayload(payload);
-        const { channels, channelUsers } = preparedPayload;
-        ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers.find(cu => cu.membership === 'member'));
+    const filter = async (payload) => {
+        const data = await prepareChannelPayload(payload);
+        ingestInCache(data);
+        callback(data.channels[0]);
+    };
+    const channelMarkerChangeHandler = async (rawPayload) => {
+        var _a;
+        const marker = rawPayload.userEntityMarkers[0];
+        const cacheKey = ['channel', 'get', marker.entityId];
+        const channel = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!channel)
+            return;
+        const updated = updateChannelMarker(channel, marker);
+        upsertInCache(cacheKey, updated);
+        callback(updated);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter),
+        createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload => callback(payload.channels[0])),
+        createEventSubscriber(client, 'onChannelUpdated', 'local.channelMarker.fetched', channelMarkerChangeHandler),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
     };
-    return createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
 };
 
 /**
  * ```js
- * import { onChannelMemberRemoved } from '@amityco/ts-sdk'
- * const dispose = onChannelMemberRemoved((channel, member) => {
+ * import { onChannelDeleted } from '@amityco/ts-sdk'
+ * const dispose = onChannelDeleted(channel => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.User} has been removed from any {@link Amity.Channel}
+ * Fired when any {@link Amity.Channel} have been deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Channel Events
  */
-const onChannelMemberRemoved = (callback) => {
+const onChannelDeleted = (callback) => {
     const client = getActiveClient();
-    const filter = (payload) => {
-        const preparedPayload = prepareChannelPayload(payload);
-        const { channels, channelUsers } = preparedPayload;
-        ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers[0]);
+    const filter = async (payload) => {
+        const data = await prepareChannelPayload(payload);
+        ingestInCache(data);
+        callback(data.channels[0]);
     };
-    return createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
+    return createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
 };
 
 /**
  * ```js
- * import { onChannelMemberBanned } from '@amityco/ts-sdk'
- * const dispose = onChannelMemberBanned((channel, member) => {
+ * import { onChannelJoined } from '@amityco/ts-sdk'
+ * const dispose = onChannelJoined((channel, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.User} has been banned from any {@link Amity.Channel}
+ * Fired when any {@link Amity.Channel} was joined
  *
  * @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 onChannelJoined = (callback) => {
     const client = getActiveClient();
-    const filter = (payload) => {
-        const preparedPayload = prepareChannelPayload(payload);
+    const filter = async (payload) => {
+        const preparedPayload = await prepareChannelPayload(payload);
         const { channels, channelUsers } = preparedPayload;
         ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers.find(cu => cu.membership === 'banned'));
+        callback(channels[0], channelUsers[0]);
     };
-    return createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
+    return createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
 };
 
 /**
  * ```js
- * import { onChannelMemberUnbanned } from '@amityco/ts-sdk'
- * const dispose = onChannelMemberUnbanned((channel, member) => {
+ * import { onChannelLeft } from '@amityco/ts-sdk'
+ * const dispose = onChannelLeft((channel, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.User} has been unbanned from any {@link Amity.Channel}
+ * Fired when any {@link Amity.Channel} was left
  *
  * @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 onChannelLeft = (callback) => {
     const client = getActiveClient();
-    const filter = (payload) => {
-        const preparedPayload = prepareChannelPayload(payload);
+    const filter = async (payload) => {
+        const preparedPayload = await prepareChannelPayload(payload);
         const { channels, channelUsers } = preparedPayload;
         ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers.find(cu => cu.membership === 'none'));
-    };
-    return createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
-};
-
-/**
- * ```js
- * import { observeChannel } from '@amityco/ts-sdk'
- *
- * let channel = {}
- * const dispose = observeChannel(channelId, ({ data }) => channel = data)
- * ```
- *
- * Observe all mutation on a given {@link Amity.Channel}
- *
- * @param channelId the ID of the channel to observe
- * @param callback the function to call when new data are available
- * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the channel
- *
- * @category Channel Observer
- */
-const observeChannel = (channelId, callback) => {
-    const { log } = getActiveClient();
-    const timestamp = Date.now();
-    log(`observeChannel(tmpid: ${timestamp}) > listen`);
-    // wrapper function to make sure
-    const router = (result, action) => {
-        var _a, _b, _c;
-        // filter function
-        if (((_a = result.data) === null || _a === void 0 ? void 0 : _a.channelId) !== channelId)
-            return;
-        if (callback instanceof Function)
-            return callback(result);
-        if (action !== 'onFetch')
-            (_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')), onChannelMuted(data => router({ data, loading: false, origin: 'event' }, 'onMute')), onChannelMemberAdded(data => router({ data, loading: false, origin: 'event' }, 'onMemberAdded')), onChannelMemberRemoved(data => router({ data, loading: false, origin: 'event' }, 'onMemberRemoved')));
-    runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));
-    return () => {
-        log(`observeChannel(tmpid: ${timestamp}) > dispose`);
-        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')), onChannelMuted(data => router(data, 'onMute')), onChannelMemberAdded(data => router(data, 'onMemberAdded')), onChannelMemberRemoved(data => router(data, 'onMemberRemoved')));
-    return () => {
-        log(`observeChannels(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
-};
-
-function hasMention(model, userId) {
-    var _a, _b;
-    const channelMention = (_a = model === null || model === void 0 ? void 0 : model.mentionees) === null || _a === void 0 ? void 0 : _a.find(x => x.type === 'channel');
-    if (channelMention) {
-        return true;
-    }
-    const userMention = (_b = model === null || model === void 0 ? void 0 : model.mentionees) === null || _b === void 0 ? void 0 : _b.find(x => x.type === 'user');
-    if (userMention) {
-        return userMention.userIds.includes(userId);
-    }
-    return false;
-}
-function isCollectionOutdated(collection, newItem, action) {
-    const key = identifyModelKey(newItem);
-    // @ts-ignore
-    const item = collection.find(x => x[key] === newItem[key]);
-    if (item) {
-        return hasUpdates(item, newItem);
-    }
-    return action === 'onCreate';
-}
-function merge(collection1, collection2) {
-    const temp = [...collection1, ...collection2];
-    if (temp.length === 0) {
-        return [];
-    }
-    const key = identifyModelKey(temp[0]);
-    const map = new Map();
-    // @ts-ignore
-    temp.forEach(x => map.set(x[key], x));
-    return Array.from(map.values());
-}
-
-/**
- * ```js
- * import { onMessageCreated } from '@amityco/ts-sdk'
- * const dispose = onMessageCreated(message => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.Message} has been created
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Message Events
- */
-const onMessageCreated = (callback) => {
-    const client = getActiveClient();
-    const filter = (rawPayload) => {
-        const payload = prepareMessagePayload(rawPayload);
-        const message = payload.messages[0];
-        const cached = pullFromCache(['channel', 'get', message.channelId]);
-        if (cached && cached.data.defaultSubChannelId === message.subChannelId) {
-            let update;
-            // @ts-ignore
-            if (cached.data.localReading) {
-                update = Object.assign(Object.assign({}, cached.data), { localReadToSegment: message.channelSegment, localLastMentionSegment: hasMention(message, client.userId)
-                        ? message.channelSegment
-                        : cached.data.localLastMentionSegment, messageCount: message.channelSegment, lastActivity: message.createdAt, updatedAt: message.createdAt });
-            }
-            else {
-                update = Object.assign(Object.assign({}, cached.data), { defaultSubChannelHasUnreadMention: hasMention(message, client.userId) || cached.data.defaultSubChannelHasUnreadMention, defaultSubChannelUnreadCount: message.channelSegment - cached.data.localReadToSegment, lastActivity: message.createdAt, messageCount: message.channelSegment, updatedAt: message.createdAt });
-            }
-            pushToCache(['channel', 'get', message.channelId], update);
-            client.emitter.emit('local.channel.updated', { channels: [update] });
-        }
-        ingestInCache(payload);
-        callback(message);
-    };
-    const disposers = [
-        createEventSubscriber(client, 'message/onMessageCreated', 'message.created', filter),
-        createEventSubscriber(client, 'local.message.created', 'local.message.created', payload => callback(payload.messages[0])),
-    ];
-    return () => {
-        disposers.forEach(fn => fn());
+        callback(channels[0], channelUsers[0]);
     };
+    return createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
 };
 
 /**
  * ```js
- * import { onMessageUpdated } from '@amityco/ts-sdk'
- * const dispose = onMessageUpdated(message => {
+ * import { onChannelMuted } from '@amityco/ts-sdk'
+ * const dispose = onChannelMuted(channel => {
  *   // ...
  * })
  * ```
  *
- * Fired when an {@link Amity.Message} has been updated
+ * Fired when any {@link Amity.Channel} have been muted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Message Events
+ * @category Channel Events
  */
-const onMessageUpdated = (callback) => {
+const onChannelMuted = (callback) => {
     const client = getActiveClient();
-    const filter = (rawPayload) => {
-        const payload = prepareMessagePayload(rawPayload);
-        ingestInCache(payload);
-        callback(payload.messages[0]);
-    };
-    const disposers = [
-        createEventSubscriber(client, 'message/onMessageUpdated', 'message.updated', filter),
-        createEventSubscriber(client, 'local.message.updated', 'local.message.updated', payload => callback(payload.messages[0])),
-    ];
-    return () => {
-        disposers.forEach(fn => fn());
+    const filter = async (payload) => {
+        const data = await prepareChannelPayload(payload);
+        ingestInCache(data);
+        callback(data.channels[0]);
     };
+    return createEventSubscriber(client, 'onChannelMuted', 'channel.setMuted', filter);
 };
 
 /**
  * ```js
- * import { onMessageDeleted } from '@amityco/ts-sdk'
- * const dispose = onMessageDeleted(message => {
+ * import { onChannelMemberAdded } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberAdded((channel, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when an {@link Amity.Message} was deleted
+ * Fired when any {@link Amity.User} has been added to 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 Message Events
+ * @category Channel Events
  */
-const onMessageDeleted = (callback) => {
+const onChannelMemberAdded = (callback) => {
     const client = getActiveClient();
-    const filter = (rawPayload) => {
-        const payload = prepareMessagePayload(rawPayload);
-        ingestInCache(payload);
-        callback(payload.messages[0]);
-    };
-    const disposers = [
-        createEventSubscriber(client, 'message/onMessageDeleted', 'message.deleted', filter),
-        createEventSubscriber(client, 'local.message.deleted', 'local.message.deleted', payload => callback(payload.messages[0])),
-    ];
-    return () => {
-        disposers.forEach(fn => fn());
+    const filter = async (payload) => {
+        const preparedPayload = await prepareChannelPayload(payload);
+        const { channels, channelUsers } = preparedPayload;
+        ingestInCache(preparedPayload);
+        callback(channels[0], channelUsers.find(cu => cu.membership === 'member'));
     };
+    return createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
 };
 
 /**
  * ```js
- * import { onMessageFlagged } from '@amityco/ts-sdk'
- * const dispose = onMessageFlagged(message => {
+ * import { onChannelMemberRemoved } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberRemoved((channel, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when a {@link Amity.Message} has been flagged
+ * Fired when any {@link Amity.User} has been removed 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 Message Events
+ * @category Channel Events
  */
-const onMessageFlagged = (callback) => {
+const onChannelMemberRemoved = (callback) => {
     const client = getActiveClient();
-    const filter = (rawPayload) => {
-        const payload = prepareMessagePayload(rawPayload);
-        ingestInCache(payload);
-        callback(payload.messages[0]);
+    const filter = async (payload) => {
+        const preparedPayload = await prepareChannelPayload(payload);
+        const { channels, channelUsers } = preparedPayload;
+        ingestInCache(preparedPayload);
+        callback(channels[0], channelUsers[0]);
     };
-    return createEventSubscriber(client, 'onMessageFlagged', 'message.flagged', filter);
+    return createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
 };
 
 /**
  * ```js
- * import { onMessageUnflagged } from '@amityco/ts-sdk'
- * const dispose = onMessageUnflagged(message => {
+ * import { onChannelMemberBanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberBanned((channel, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when a flag has been removed from a {@link Amity.Message}
+ * 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 Message Events
+ * @category Channel Events
  */
-const onMessageUnflagged = (callback) => {
+const onChannelMemberBanned = (callback) => {
     const client = getActiveClient();
-    const filter = (rawPayload) => {
-        const payload = prepareMessagePayload(rawPayload);
-        ingestInCache(payload);
-        callback(payload.messages[0]);
+    const filter = async (payload) => {
+        const preparedPayload = await prepareChannelPayload(payload);
+        const { channels, channelUsers } = preparedPayload;
+        ingestInCache(preparedPayload);
+        callback(channels[0], channelUsers.find(cu => cu.membership === 'banned'));
     };
-    return createEventSubscriber(client, 'onMessageUnflagged', 'message.unflagged', filter);
+    return createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
 };
 
 /**
  * ```js
- * import { onMessageFlagCleared } from '@amityco/ts-sdk'
- * const dispose = onMessageFlagCleared(message => {
+ * import { onChannelMemberUnbanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberUnbanned((channel, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when flags have been cleared for a {@link Amity.Message}
+ * 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 Message Events
+ * @category Channel Events
  */
-const onMessageFlagCleared = (callback) => {
+const onChannelMemberUnbanned = (callback) => {
     const client = getActiveClient();
-    const filter = (rawPayload) => {
-        const payload = prepareMessagePayload(rawPayload);
-        ingestInCache(payload);
-        callback(payload.messages[0]);
+    const filter = async (payload) => {
+        const preparedPayload = await prepareChannelPayload(payload);
+        const { channels, channelUsers } = preparedPayload;
+        ingestInCache(preparedPayload);
+        callback(channels[0], channelUsers.find(cu => cu.membership === 'none'));
     };
-    return createEventSubscriber(client, 'onMessageFlagCleared', 'message.flagCleared', filter);
+    return createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
 };
 
 /**
  * ```js
- * import { onMessageReactionAdded } from '@amityco/ts-sdk';
+ * import { observeChannel } from '@amityco/ts-sdk'
  *
- * const unsubscribe = onMessageReactionAdded(message => {
- *   // ...
- * });
+ * let channel = {}
+ * const dispose = observeChannel(channelId, ({ data }) => channel = data)
  * ```
  *
- * Fired when a {@link Amity.Message} has been reacted
+ * Observe all mutation on a given {@link Amity.Channel}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param channelId the ID of the channel to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the channel
  *
- * @category Post Events
+ * @category Channel Observer
  */
-const onMessageReactionAdded = (callback) => {
-    const client = getActiveClient();
-    const filter = (rawPayload) => {
-        const payload = prepareMessagePayload(rawPayload);
-        ingestInCache(payload);
-        callback(payload.messages[0]);
+const observeChannel = (channelId, callback) => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    log(`observeChannel(tmpid: ${timestamp}) > listen`);
+    // wrapper function to make sure
+    const router = (result, action) => {
+        var _a, _b, _c;
+        // filter function
+        if (((_a = result.data) === null || _a === void 0 ? void 0 : _a.channelId) !== channelId)
+            return;
+        if (callback instanceof Function)
+            return callback(result);
+        if (action !== 'onFetch')
+            (_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')), onChannelMuted(data => router({ data, loading: false, origin: 'event' }, 'onMute')), onChannelMemberAdded(data => router({ data, loading: false, origin: 'event' }, 'onMemberAdded')), onChannelMemberRemoved(data => router({ data, loading: false, origin: 'event' }, 'onMemberRemoved')));
+    runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));
+    return () => {
+        log(`observeChannel(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
     };
-    return createEventSubscriber(client, 'onMessageReactionAdded', 'message.reactionAdded', filter);
 };
 
 /**
  * ```js
- * import { onMessageReactionRemoved } from '@amityco/ts-sdk';
+ * import { observeChannels } from '@amityco/ts-sdk'
  *
- * const unsubscribe = onMessageReactionRemoved(message => {
- *   // ...
- * });
+ * let channels = []
+ * const unsub = observeChannels(channel => merge(channels, channel))
  * ```
  *
- * Fired when a reaction has been removed from a {@link Amity.Message}
+ * Observe all mutations on a list of {@link Amity.Channel} for a current user
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @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 Post Events
+ * @category Channel Observer
  */
-const onMessageReactionRemoved = (callback) => {
-    const client = getActiveClient();
-    const filter = (rawPayload) => {
-        const payload = prepareMessagePayload(rawPayload);
-        ingestInCache(payload);
-        callback(payload.messages[0]);
+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')), onChannelMuted(data => router(data, 'onMute')), onChannelMemberAdded(data => router(data, 'onMemberAdded')), onChannelMemberRemoved(data => router(data, 'onMemberRemoved')));
+    return () => {
+        log(`observeChannels(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
     };
-    return createEventSubscriber(client, 'onMessageReactionRemoved', 'message.reactionRemoved', filter);
 };
 
 /**
@@ -27078,22 +27883,6 @@ const liveChannelMembers = (params, callback, config) => {
     };
 };
 
-function convertFromRaw(_a) {
-    var { channelId, channelPublicId, channelType, childCount, creatorId, creatorPublicId, lastMessageId, lastMessageTimestamp, messageFeedId, name } = _a, rest = __rest(_a, ["channelId", "channelPublicId", "channelType", "childCount", "creatorId", "creatorPublicId", "lastMessageId", "lastMessageTimestamp", "messageFeedId", "name"]);
-    return Object.assign(Object.assign({}, rest), { channelId: channelPublicId, creatorId: creatorPublicId, displayName: name, lastActivity: lastMessageTimestamp, latestMessageId: lastMessageId, messageCount: childCount, subChannelId: messageFeedId });
-}
-const prepareSubChannelPayload = (payload) => {
-    return Object.assign(Object.assign({}, payload), { messageFeeds: payload.messageFeeds.map(convertFromRaw) });
-};
-function convertQueryParams(_a) {
-    var { excludeDefaultSubChannel } = _a, rest = __rest(_a, ["excludeDefaultSubChannel"]);
-    const out = Object.assign({}, rest);
-    if (excludeDefaultSubChannel !== undefined) {
-        out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
-    }
-    return out;
-}
-
 /* begin_public_function
   id: subchannel.query
 */
@@ -27121,7 +27910,7 @@ const querySubChannels = async (query) => {
             } }),
     });
     const _b = response.data, { paging } = _b, payload = __rest(_b, ["paging"]);
-    const data = prepareSubChannelPayload(payload);
+    const data = await prepareSubChannelPayload(payload);
     const subChannels = data.messageFeeds;
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
@@ -27197,7 +27986,7 @@ const getSubChannels = async (subChannelIds) => {
     const response = await client.http.get('/api/v5/message-feeds/list', {
         params: { messageFeedIds: subChannelIds.map(encodeURIComponent) },
     });
-    const data = prepareSubChannelPayload(response.data);
+    const data = await prepareSubChannelPayload(response.data);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -27262,7 +28051,7 @@ const getSubChannel = async (subChannelId) => {
     isInTombstone('subChannel', subChannelId);
     try {
         const response = await client.http.get(`/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`);
-        const data = prepareSubChannelPayload(response.data);
+        const data = await prepareSubChannelPayload(response.data);
         const cachedAt = client.cache && Date.now();
         if (client.cache)
             ingestInCache(data, { cachedAt });
@@ -27331,7 +28120,7 @@ const createSubChannel = async (bundle) => {
         channelId: bundle.channelId,
         name: bundle.displayName,
     });
-    const data = prepareSubChannelPayload(response.data);
+    const data = await prepareSubChannelPayload(response.data);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -27365,7 +28154,7 @@ const updateSubChannel = async (subChannelId, patch) => {
     const client = getActiveClient();
     client.log('channel/updateSubChannel', subChannelId, patch);
     const response = await client.http.put(`/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`, { name: patch.displayName });
-    const data = prepareSubChannelPayload(response.data);
+    const data = await prepareSubChannelPayload(response.data);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -27413,87 +28202,6 @@ const deleteSubChannel = async (subChannelId, permanent = false) => {
 };
 /* end_public_function */
 
-/**
- * ```js
- * import { onChannelSubCreated } from '@amityco/ts-sdk'
- * const dispose = onSubChannelCreated(subChannel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.SubChannel} have been created
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-const onSubChannelCreated = (callback) => {
-    const client = getActiveClient();
-    const filter = (rawPayload) => {
-        const payload = prepareSubChannelPayload(rawPayload);
-        ingestInCache(payload);
-        callback(payload.messageFeeds[0]);
-    };
-    return createEventSubscriber(client, 'onSubChannelCreated', 'message-feed.created', filter);
-};
-
-/**
- * ```js
- * import { onSubChannelUpdated } from '@amityco/ts-sdk'
- * const dispose = onSubChannelUpdated(subChannel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.SubChannel} have been updated
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-const onSubChannelUpdated = (callback) => {
-    const client = getActiveClient();
-    const filter = (rawPayload) => {
-        const payload = prepareSubChannelPayload(rawPayload);
-        ingestInCache(payload);
-        callback(payload.messageFeeds[0]);
-    };
-    return createEventSubscriber(client, 'onSubChannelUpdated', 'message-feed.updated', filter);
-};
-
-/**
- * ```js
- * import { onSubChannelDeleted } from '@amityco/ts-sdk'
- * const dispose = onSubChannelDeleted(subChannel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.SubChannel} have been deleted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-const onSubChannelDeleted = (callback) => {
-    const client = getActiveClient();
-    const filter = (rawPayload) => {
-        const payload = prepareSubChannelPayload(rawPayload);
-        ingestInCache(payload);
-        callback(payload.messageFeeds[0]);
-    };
-    const disposers = [
-        createEventSubscriber(client, 'onSubChannelDeleted', 'message-feed.deleted', filter),
-        createEventSubscriber(client, 'local.message-feed.deleted', 'local.message-feed.deleted', payload => callback(payload.messageFeeds[0])),
-    ];
-    return () => {
-        disposers.forEach(fn => fn());
-    };
-};
-
 /** @hidden */
 const onSubChannelFetched = (callback) => {
     return createEventSubscriber(getActiveClient(), 'onSubChannelFetched', 'local.message-feed.fetched', payload => callback(payload.messageFeeds[0]));
@@ -27526,6 +28234,27 @@ const liveSubChannel = (subChannelId, callback) => {
     ]);
 };
 
+function isCollectionOutdated(collection, newItem, action) {
+    const key = identifyModelKey(newItem);
+    // @ts-ignore
+    const item = collection.find(x => x[key] === newItem[key]);
+    if (item) {
+        return hasUpdates(item, newItem);
+    }
+    return action === 'onCreate';
+}
+function merge(collection1, collection2) {
+    const temp = [...collection1, ...collection2];
+    if (temp.length === 0) {
+        return [];
+    }
+    const key = identifyModelKey(temp[0]);
+    const map = new Map();
+    // @ts-ignore
+    temp.forEach(x => map.set(x[key], x));
+    return Array.from(map.values());
+}
+
 /**
  * ```js
  * import { liveSubChannels } from '@amityco/ts-sdk';
@@ -27610,30 +28339,6 @@ const liveSubChannels = (params, callback, config) => {
     };
 };
 
-/**
- * ```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', 'local.message.fetched', filter);
-};
-
 /**
  * ```js
  * import { liveMessage } from '@amityco/ts-sdk';
@@ -30638,6 +31343,7 @@ exports.CommunityPostSettings = CommunityPostSettings;
 exports.ContentFeedType = ContentFeedType;
 exports.DefaultCommunityPostSetting = DefaultCommunityPostSetting;
 exports.FileType = FileType;
+exports.MARKER_INCLUDED_SUB_CHANNEL_TYPE = MARKER_INCLUDED_SUB_CHANNEL_TYPE;
 exports.MessageContentType = MessageContentType;
 exports.PostContentType = PostContentType;
 exports.VERSION = VERSION;
@@ -30655,6 +31361,8 @@ exports.backupCache = backupCache;
 exports.banChannelMembers = banChannelMembers;
 exports.closePoll = closePoll;
 exports.connectClient = connectClient;
+exports.convertFromRaw = convertFromRaw$1;
+exports.convertQueryParams = convertQueryParams;
 exports.createChannel = createChannel;
 exports.createClient = createClient;
 exports.createComment = createComment;
@@ -30694,8 +31402,10 @@ exports.filterByPropEquality = filterByPropEquality;
 exports.filterByPropInclusion = filterByPropInclusion;
 exports.follow = follow;
 exports.getActiveClient = getActiveClient;
+exports.getActiveUser = getActiveUser;
 exports.getCategory = getCategory;
 exports.getChannel = getChannel;
+exports.getChannelMarkers = getChannelMarkers;
 exports.getChannelTopic = getChannelTopic;
 exports.getChannels = getChannels;
 exports.getComment = getComment;
@@ -30707,7 +31417,9 @@ exports.getCommunityTopic = getCommunityTopic;
 exports.getFeedSettings = getFeedSettings;
 exports.getFile = getFile;
 exports.getFollowInfo = getFollowInfo;
+exports.getMarkerSyncEvents = getMarkerSyncEvents;
 exports.getMessage = getMessage;
+exports.getMessageMarkers = getMessageMarkers;
 exports.getMessageTopic = getMessageTopic;
 exports.getMessages = getMessages;
 exports.getMyFollowersTopic = getMyFollowersTopic;
@@ -30724,10 +31436,14 @@ exports.getSmartFeedMessageTopic = getSmartFeedMessageTopic;
 exports.getSmartFeedSubChannelTopic = getSmartFeedSubChannelTopic;
 exports.getStream = getStream;
 exports.getSubChannel = getSubChannel;
+exports.getSubChannelMarkers = getSubChannelMarkers;
 exports.getSubChannelTopic = getSubChannelTopic;
 exports.getSubChannels = getSubChannels;
 exports.getTopTrendingCommunities = getTopTrendingCommunities;
+exports.getTotalUnreadCount = getTotalUnreadCount;
+exports.getUnreadCount = getUnreadCount$1;
 exports.getUser = getUser;
+exports.getUserMarker = getUserMarker;
 exports.getUserTopic = getUserTopic;
 exports.getUsers = getUsers;
 exports.isAfterBefore = isAfterBefore;
@@ -30742,6 +31458,7 @@ exports.isOffline = isOffline;
 exports.isPaged = isPaged;
 exports.isReportedByMe = isReportedByMe;
 exports.isSkip = isSkip;
+exports.isUnreadCountSupport = isUnreadCountSupport$1;
 exports.joinChannel = joinChannel;
 exports.joinCommunity = joinCommunity;
 exports.leaveChannel = leaveChannel;
@@ -30767,6 +31484,9 @@ exports.liveSubChannel = liveSubChannel;
 exports.liveSubChannels = liveSubChannels;
 exports.liveUser = liveUser;
 exports.liveUsers = liveUsers;
+exports.markAsDelivered = markAsDelivered;
+exports.markerSync = markerSync;
+exports.markerSyncTrigger = markerSyncTrigger;
 exports.mergeInCache = mergeInCache;
 exports.observeChannel = observeChannel;
 exports.observeChannels = observeChannels;
@@ -30787,6 +31507,7 @@ exports.onChannelCreated = onChannelCreated;
 exports.onChannelDeleted = onChannelDeleted;
 exports.onChannelJoined = onChannelJoined;
 exports.onChannelLeft = onChannelLeft;
+exports.onChannelMarkerFetched = onChannelMarkerFetched;
 exports.onChannelMemberAdded = onChannelMemberAdded;
 exports.onChannelMemberBanned = onChannelMemberBanned;
 exports.onChannelMemberRemoved = onChannelMemberRemoved;
@@ -30815,6 +31536,7 @@ exports.onCommunityUserRoleAdded = onCommunityUserRoleAdded;
 exports.onCommunityUserRoleRemoved = onCommunityUserRoleRemoved;
 exports.onCommunityUserUnbanned = onCommunityUserUnbanned;
 exports.onConnectionError = onConnectionError;
+exports.onFeedMarkerFetched = onFeedMarkerFetched;
 exports.onFollowInfoUpdated = onFollowInfoUpdated;
 exports.onFollowRequestAccepted = onFollowRequestAccepted;
 exports.onFollowRequestCanceled = onFollowRequestCanceled;
@@ -30823,8 +31545,10 @@ exports.onFollowerDeleted = onFollowerDeleted;
 exports.onFollowerRequested = onFollowerRequested;
 exports.onMessageCreated = onMessageCreated;
 exports.onMessageDeleted = onMessageDeleted;
+exports.onMessageFetched = onMessageFetched;
 exports.onMessageFlagCleared = onMessageFlagCleared;
 exports.onMessageFlagged = onMessageFlagged;
+exports.onMessageMarkerFetched = onMessageMarkerFetched;
 exports.onMessageReactionAdded = onMessageReactionAdded;
 exports.onMessageReactionRemoved = onMessageReactionRemoved;
 exports.onMessageUnflagged = onMessageUnflagged;
@@ -30850,15 +31574,20 @@ exports.onStreamStarted = onStreamStarted;
 exports.onStreamStopped = onStreamStopped;
 exports.onSubChannelCreated = onSubChannelCreated;
 exports.onSubChannelDeleted = onSubChannelDeleted;
+exports.onSubChannelMarkerFetched = onSubChannelMarkerFetched;
+exports.onSubChannelMarkerUpdated = onSubChannelMarkerUpdated;
 exports.onSubChannelUpdated = onSubChannelUpdated;
 exports.onUserDeleted = onUserDeleted;
 exports.onUserFlagCleared = onUserFlagCleared;
 exports.onUserFlagged = onUserFlagged;
 exports.onUserFollowed = onUserFollowed;
+exports.onUserMarkerFetched = onUserMarkerFetched;
 exports.onUserUnflagged = onUserUnflagged;
 exports.onUserUnfollowed = onUserUnfollowed;
 exports.onUserUpdated = onUserUpdated;
+exports.prepareSubChannelPayload = prepareSubChannelPayload;
 exports.pullFromCache = pullFromCache;
+exports.pushMarkerSyncEvent = pushMarkerSyncEvent;
 exports.pushToCache = pushToCache;
 exports.queryCache = queryCache;
 exports.queryCategories = queryCategories;
@@ -30886,6 +31615,8 @@ exports.removeReaction = removeReaction;
 exports.renewal = renewal;
 exports.restoreCache = restoreCache;
 exports.runQuery = runQuery;
+exports.setActiveUser = setActiveUser;
+exports.setMarkerSyncEvents = setMarkerSyncEvents;
 exports.sortByChannelSegment = sortByChannelSegment;
 exports.sortByDisplayName = sortByDisplayName;
 exports.sortByFirstCreated = sortByFirstCreated;
@@ -30894,7 +31625,11 @@ exports.sortByLastCreated = sortByLastCreated;
 exports.sortByName = sortByName;
 exports.sortBySegmentNumber = sortBySegmentNumber;
 exports.startReading = startReading;
+exports.startReadingAPI = startReadingAPI;
+exports.startUnreadSync = startUnreadSync;
 exports.stopReading = stopReading;
+exports.stopReadingAPI = stopReadingAPI;
+exports.stopUnreadSyncing = stopUnreadSyncing;
 exports.subscribeTopic = subscribeTopic;
 exports.toPage = toPage;
 exports.toPageRaw = toPageRaw;
@@ -30908,6 +31643,7 @@ exports.updateMessage = updateMessage;
 exports.updatePost = updatePost;
 exports.updateStream = updateStream;
 exports.updateSubChannel = updateSubChannel;
+exports.updateSubChannelMarker = updateSubChannelMarker;
 exports.updateUser = updateUser;
 exports.upsertInCache = upsertInCache;
 exports.votePoll = votePoll;