@amityco/ts-sdk 7.29.1-cc0fba8.0 → 7.30.0

package/dist/index.esm.js

@@ -1,4 +1,4 @@
-import { encode, decode, btoa, atob } from 'js-base64';
+import { encode, decode, toUint8Array, btoa, atob } from 'js-base64';
 import mitt from 'mitt';
 import debug from 'debug';
 import axios from 'axios';
@@ -54,6 +54,21 @@ var UserProfileFieldEnum;
     UserProfileFieldEnum["DESCRIPTION"] = "description";
     UserProfileFieldEnum["AVATAR"] = "avatarFileId";
 })(UserProfileFieldEnum || (UserProfileFieldEnum = {}));
+/**
+ * Selects which of the caller's reports `UserRepository.unflagUser` withdraws, sent as the
+ * `reportType` query parameter. The four typed members are the backend `reportType` wire
+ * values and match `UserReportTypeEnum`. `UNTYPED` selects the typeless (legacy) report,
+ * which `user.getUserFlagsByMe()` returns as `reportType: null`; it is a selector only, never
+ * stored, and the flag endpoint refuses it.
+ */
+var UserReportTypeFilterEnum;
+(function (UserReportTypeFilterEnum) {
+    UserReportTypeFilterEnum["DISPLAY_NAME"] = "displayName";
+    UserReportTypeFilterEnum["DESCRIPTION"] = "description";
+    UserReportTypeFilterEnum["AVATAR"] = "avatarFileId";
+    UserReportTypeFilterEnum["BEHAVIOR"] = "behavior";
+    UserReportTypeFilterEnum["UNTYPED"] = "untyped";
+})(UserReportTypeFilterEnum || (UserReportTypeFilterEnum = {}));
 
 const FileType = Object.freeze({
     FILE: 'file',
@@ -328,8 +343,8 @@ var AmityLiveViewerCountMode;
 
 function getVersion() {
     try {
-        // the string ''v7.29.0-esm'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v7.29.0-esm';
+        // the string ''v7.30.0-esm'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v7.30.0-esm';
     }
     catch (error) {
         return '__dev__';
@@ -1615,6 +1630,24 @@ const sortByLastUpdated = ({ updatedAt: a = 0 }, { updatedAt: b = 0 }) => new Da
  * Sorting a collection by the items with most recent activity
  */
 const sortByLastActivity = ({ lastActivity: a }, { lastActivity: b }) => new Date(b).valueOf() - new Date(a).valueOf();
+/**
+ * Sorting a channel collection by the time of its newest message (newest first).
+ * Channels whose `lastMessageAt` is `null` sort last, ordered by `createdAt`
+ * (newest first) among themselves, matching the server's `sortBy=lastMessage`
+ * order so the local sort agrees with the page order.
+ */
+const sortByLastMessage = (a, b) => {
+    var _a, _b;
+    const aAt = (_a = a.lastMessageAt) !== null && _a !== void 0 ? _a : null;
+    const bAt = (_b = b.lastMessageAt) !== null && _b !== void 0 ? _b : null;
+    if (aAt !== null && bAt !== null)
+        return new Date(bAt).valueOf() - new Date(aAt).valueOf();
+    if (aAt !== null)
+        return -1;
+    if (bAt !== null)
+        return 1;
+    return new Date(b.createdAt).valueOf() - new Date(a.createdAt).valueOf();
+};
 /**
  * Filter items by untilAt timestamp based on sort direction
  * - For 'lastCreated' (newest first): untilAt acts as lower bound, excludes items older than boundary
@@ -1699,8 +1732,13 @@ const scheduleTask = (task) => {
     clearTimeout(timer);
     tasks.push(task);
     timer = setTimeout(() => {
-        tasks.forEach(fn => fn());
+        // Swap the queue out before running it. A task that schedules another task
+        // while the batch runs (an event handler that fires an event) must land in
+        // a fresh queue and its own timer, not in the array being drained and then
+        // discarded.
+        const batch = tasks;
         tasks = [];
+        batch.forEach(fn => fn());
     }, 0);
 };
 
@@ -1798,18 +1836,434 @@ async function modifyMqttConnection() {
     }
 }
 
+class SessionWatcher {
+    constructor() {
+        this._sessionState = "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */;
+        this._listener = new Map();
+    }
+    onSessionStateChange(callback) {
+        this._listener.set(callback, callback);
+        return () => {
+            this._listener.delete(callback);
+        };
+    }
+    setSessionState(state, reason) {
+        if (this._sessionState === state)
+            return;
+        this._sessionState = state;
+        this._listener.forEach(cb => cb(state, reason));
+    }
+    destroy() {
+        this._listener.clear();
+    }
+}
+let instance$b;
+var SessionWatcher$1 = {
+    getInstance: () => {
+        if (!instance$b) {
+            instance$b = new SessionWatcher();
+        }
+        return instance$b;
+    },
+};
+
+/**
+ * ```js
+ * import { onSessionStateChange } from '@amityco/ts-sdk'
+ * const dispose = onSessionStateChange((state: Amity.SessionStates) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} has a session state change
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+const onSessionStateChange = (callback) => SessionWatcher$1.getInstance().onSessionStateChange(callback);
+
+/**
+ * ```js
+ * import { getFlagsByMe } from '~/userRepository/internalApi/getFlagsByMe'
+ * const { isFlagByMe, flags } = await getFlagsByMe('userId')
+ * ```
+ *
+ * The v4 read behind `user.getUserFlagsByMe()`, the background confirm of
+ * `user.isFlaggedByMe`, and the deprecated `UserRepository.isUserFlaggedByMe`:
+ * `GET /api/v4/users/:userId/isFlagByMe`, returned as received. Nothing is filtered, cached or
+ * persisted here, and `hashFlag` is not consulted.
+ * This is the Web counterpart of iOS `ASCUserService.getFlagsByMe` and Android
+ * `UserRepository.getFlagsByMe`, kept apart from the deprecated public function so the
+ * user-object read does not change if that function ever does.
+ *
+ * @param userId The ID of the user whose reports by the caller are read
+ * @returns the caller's {@link Amity.UserFlagByMe} on that user
+ *
+ * @category Private
+ * @async
+ */
+const getFlagsByMe = async (userId) => {
+    const client = getActiveClient();
+    client.log('user/getFlagsByMe', userId);
+    const { data } = await client.http.get(`/api/v4/users/${encodeURIComponent(userId)}/isFlagByMe`);
+    return data;
+};
+
+/* eslint-disable no-bitwise */
+/**
+ * Client-side test of the `hashFlag` Bloom filter the backend attaches to flaggable objects.
+ *
+ * The filter holds the ids of every user who flagged the object: `bits` is its size, `hashes`
+ * the number of hash functions per id and `hash` the bit array, base64-encoded. This is a port
+ * of the test iOS (`_BloomFilter`) and Android (`EkoBloomFilter`) already run: FNV-1a 32-bit
+ * over the UTF-8 bytes of the id with seeds `0` and `1576284489`, combined by double hashing
+ * (`(a + i·b) mod bits`). A Bloom filter has no false negatives, so `false` is exact; `true`
+ * means "probably", because another id's hashes may have set the same bits. The filter knows
+ * nothing about report types.
+ */
+const FNV_OFFSET_BASIS = 0x811c9dc5;
+const FNV_PRIME = 16777619;
+const SECOND_SEED = 1576284489;
+/** FNV-1a with the same mixing step and signed-byte handling as the native SDKs. */
+const fnv1a = (bytes, seed) => {
+    let a = (FNV_OFFSET_BASIS ^ seed) >>> 0;
+    for (let i = 0; i < bytes.length; i += 1) {
+        // Bytes are `char` on iOS and `byte` on Android: both signed, so 0x80..0xff sign-extend.
+        const byte = bytes[i] > 127 ? bytes[i] - 256 : bytes[i];
+        a = Math.imul((a ^ byte) >>> 0, FNV_PRIME) >>> 0;
+    }
+    a = (a + (a << 13)) >>> 0;
+    a = (a ^ (a >>> 7)) >>> 0;
+    a = (a + (a << 3)) >>> 0;
+    a = (a ^ (a >>> 17)) >>> 0;
+    a = (a + (a << 5)) >>> 0;
+    return a;
+};
+/** Bit positions for `value`, reproducing the native SDKs' signed 32-bit arithmetic. */
+const locationsFor = (value, bits, hashes) => {
+    const bytes = toUint8Array(encode(value)); // UTF-8 bytes of the id
+    const a = fnv1a(bytes, 0) | 0;
+    const b = fnv1a(bytes, SECOND_SEED) | 0;
+    const locations = [];
+    let x = a % bits;
+    for (let i = 0; i < hashes; i += 1) {
+        locations.push(x < 0 ? x + bits : x);
+        x = ((x + b) | 0) % bits;
+    }
+    return locations;
+};
+/** Standard or URL-safe base64, padding optional. Anything else is not a filter we can read. */
+const BASE64 = /^[A-Za-z0-9+/_-]*={0,2}$/;
+/**
+ * Whether `value` is probably in the filter. `false` is exact; `true` means "maybe", which may be
+ * a false positive. `null` (the server's value when nobody has flagged the object), a missing
+ * filter or a missing value answer `false`.
+ *
+ * A filter that cannot be read answers `true` ("maybe") and never throws, so the caller asks the
+ * server instead of trusting a "definitely not" it cannot back up (REQ-017): `bits` or `hashes`
+ * not a positive integer, a `hash` that is not base64, or a `hash` shorter than `ceil(bits / 8)`
+ * bytes.
+ */
+const testBloomFilter = (hashFlag, value) => {
+    if (!hashFlag || !value)
+        return false;
+    const { bits, hashes, hash } = hashFlag;
+    if (!Number.isInteger(bits) || bits <= 0)
+        return true;
+    if (!Number.isInteger(hashes) || hashes <= 0)
+        return true;
+    if (typeof hash !== 'string' || !BASE64.test(hash))
+        return true;
+    let buckets;
+    try {
+        buckets = toUint8Array(hash);
+    }
+    catch (_a) {
+        return true;
+    }
+    if (buckets.length < Math.ceil(bits / 8))
+        return true;
+    const locations = locationsFor(value, bits, hashes);
+    for (let i = 0; i < locations.length; i += 1) {
+        const index = Math.floor(locations[i] / 8);
+        const bit = 1 << locations[i] % 8;
+        if ((buckets[index] & bit) === 0)
+            return false;
+    }
+    return true;
+};
+
+/**
+ * Flag state of the current user on a target user, behind `Amity.User.isFlaggedByMe` and
+ * `Amity.User.getUserFlagsByMe()` (`user.check_flag_by_me` v1, REQ-011, REQ-012, REQ-016).
+ *
+ * `hashFlag` is a Bloom filter of reporter ids. "Definitely not" is exact. "Maybe" can be a
+ * false positive caused by other reporters, so the SDK confirms it with the server once per
+ * `hashFlag` value and records the answer in the cache under its own key, never on the user's
+ * cache row (REQ-015). Observers are told through `local.user.flagConfirmed` when a recorded
+ * answer changes what a user object would show.
+ *
+ * Not exported from the public API.
+ */
+/** Confirms for the same user are at least this far apart, as Android's `EkoFlag.expired`. */
+const FLAG_CONFIRM_INTERVAL = 1000;
+const cacheKey = (userId) => ['userFlagByMe', 'get', userId];
+const lastConfirmAt = new Map();
+/**
+ * Bumped by the current user's own flag and unflag. A confirm or exact read that started before
+ * one of them must not record its answer, because the write may have changed it while the
+ * `hashFlag` stayed the same.
+ */
+const generations = new Map();
+const generationOf = (userId) => { var _a; return (_a = generations.get(userId)) !== null && _a !== void 0 ? _a : 0; };
+const bumpGeneration = (userId) => generations.set(userId, generationOf(userId) + 1);
+/** The current user's id, or `undefined` when there is no active client. Never throws. */
+const currentUserId = () => {
+    try {
+        return getActiveClient().userId;
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+const readRecord = (userId) => {
+    var _a;
+    try {
+        return (_a = pullFromCache(cacheKey(userId))) === null || _a === void 0 ? void 0 : _a.data;
+    }
+    catch (_b) {
+        return undefined;
+    }
+};
+/**
+ * The server's answer recorded for this user and this exact `hashFlag`, or `undefined` when there
+ * is none for the current user. Never throws.
+ */
+const readConfirmedFlag = (userId, hashFlag) => {
+    const me = currentUserId();
+    if (!me || !hashFlag || typeof hashFlag.hash !== 'string')
+        return undefined;
+    const record = readRecord(userId);
+    if (!record || record.reporterId !== me || record.hash !== hashFlag.hash)
+        return undefined;
+    return record.isFlagByMe;
+};
+/**
+ * The v4 request in flight per user, with the generation it started in. A confirm and an exact
+ * read of the same user share one request; a request that started before the current user's own
+ * flag or unflag is not joined.
+ */
+const inFlight = new Map();
+const requestFlagsByMe = (userId) => {
+    const generation = generationOf(userId);
+    const pending = inFlight.get(userId);
+    if (pending && pending.generation === generation)
+        return pending.promise;
+    const promise = getFlagsByMe(userId).finally(() => {
+        var _a;
+        if (((_a = inFlight.get(userId)) === null || _a === void 0 ? void 0 : _a.promise) === promise)
+            inFlight.delete(userId);
+    });
+    inFlight.set(userId, { generation, promise });
+    return promise;
+};
+const notifyObservers = (userId) => fireEvent('local.user.flagConfirmed', { userId });
+/**
+ * Records `isFlagByMe` for `hashFlag`. A "maybe" without a record shows `true`, so observers are
+ * told only when the shown value changes.
+ */
+const recordFlag = (userId, hashFlag, isFlagByMe) => {
+    var _a;
+    const me = currentUserId();
+    if (!me || typeof hashFlag.hash !== 'string')
+        return;
+    const shown = (_a = readConfirmedFlag(userId, hashFlag)) !== null && _a !== void 0 ? _a : true;
+    const record = { reporterId: me, hash: hashFlag.hash, isFlagByMe };
+    pushToCache(cacheKey(userId), record);
+    if (shown !== isFlagByMe)
+        notifyObservers(userId);
+};
+/**
+ * Starts one background confirm of a "maybe" (REQ-016): at most one in flight per user, and
+ * confirms for the same user at least {@link FLAG_CONFIRM_INTERVAL} apart. A failed confirm
+ * records nothing, surfaces no error, and a later read tries again.
+ */
+const confirmFlagByMe = (userId, hashFlag) => {
+    if (inFlight.has(userId))
+        return;
+    const now = Date.now();
+    const last = lastConfirmAt.get(userId);
+    if (last !== undefined && now - last < FLAG_CONFIRM_INTERVAL)
+        return;
+    const me = currentUserId();
+    const generation = generationOf(userId);
+    lastConfirmAt.set(userId, now);
+    requestFlagsByMe(userId)
+        .then(({ isFlagByMe }) => {
+        if (currentUserId() !== me || generationOf(userId) !== generation)
+            return;
+        recordFlag(userId, hashFlag, isFlagByMe);
+    })
+        .catch(() => {
+        // Not an answer: isFlaggedByMe stays true until a later read confirms again.
+    });
+};
+/**
+ * The value of `Amity.User.isFlaggedByMe` for a user object whose confirmed answer was captured
+ * (`confirmed`) when the object was linked, so a held object never changes (REQ-014).
+ *
+ * - No current user, `hashFlag: null` or a missing `hashFlag`, or "definitely not": `false`.
+ * - "Maybe" with a confirmed answer: that answer, no request.
+ * - "Maybe" without one: `true`, and one background confirm (REQ-016).
+ *
+ * The linked object declares this as a getter inside an object spread, which the build compiles
+ * to `Object.assign`, so it runs once when the user is linked and the object keeps that value.
+ */
+const isFlaggedByMeFor = (user, confirmed) => {
+    const me = currentUserId();
+    if (!me || !user.hashFlag || !testBloomFilter(user.hashFlag, me))
+        return false;
+    if (confirmed !== undefined)
+        return confirmed;
+    confirmFlagByMe(user.userId, user.hashFlag);
+    return true;
+};
+const NOT_FLAGGED = { isFlagByMe: false, flags: [] };
+const isNotOlder = (next, current) => {
+    var _a, _b;
+    const nextAt = Date.parse((_a = next.updatedAt) !== null && _a !== void 0 ? _a : '');
+    const currentAt = Date.parse((_b = current.updatedAt) !== null && _b !== void 0 ? _b : '');
+    return Number.isNaN(nextAt) || Number.isNaN(currentAt) || nextAt >= currentAt;
+};
+/**
+ * One `getUserFlagsByMe` closure per userId, remembering the newest user object linked for that
+ * id. Live objects and collections compare snapshots with `isEqual`, which compares functions by
+ * reference, so a fresh closure per linked object would re-dispatch unchanged snapshots
+ * (REQ-015). An older snapshot linked later does not replace a newer one.
+ */
+const flagsByMeEntries = new Map();
+/**
+ * `Amity.User.getUserFlagsByMe()` (REQ-012): `{ isFlagByMe: false, flags: [] }` with no request
+ * when the newest linked user says "not flagged", including a confirmed `false`. Otherwise the
+ * v4 read, returned as is; a confirm already in flight for the user is joined instead of sending
+ * a second request. Its `isFlagByMe` is recorded as the confirmed answer for the
+ * `hashFlag` it was read for; `flags[]` is never stored (REQ-009). A missing `hashFlag` is
+ * unknown, so the server is asked.
+ */
+const readFlagsByMe = async (userId) => {
+    var _a, _b;
+    const me = currentUserId();
+    const { hashFlag } = (_b = (_a = flagsByMeEntries.get(userId)) === null || _a === void 0 ? void 0 : _a.latest) !== null && _b !== void 0 ? _b : {};
+    if (me && hashFlag !== undefined) {
+        if (!hashFlag || !testBloomFilter(hashFlag, me))
+            return Object.assign(Object.assign({}, NOT_FLAGGED), { flags: [] });
+        if (readConfirmedFlag(userId, hashFlag) === false)
+            return Object.assign(Object.assign({}, NOT_FLAGGED), { flags: [] });
+    }
+    const generation = generationOf(userId);
+    const result = await requestFlagsByMe(userId);
+    if (hashFlag && currentUserId() === me && generationOf(userId) === generation) {
+        recordFlag(userId, hashFlag, result.isFlagByMe);
+    }
+    return result;
+};
+const getUserFlagsByMeFor = (user) => {
+    let entry = flagsByMeEntries.get(user.userId);
+    if (!entry) {
+        entry = { latest: user, getUserFlagsByMe: () => readFlagsByMe(user.userId) };
+        flagsByMeEntries.set(user.userId, entry);
+    }
+    else if (isNotOlder(user, entry.latest)) {
+        entry.latest = user;
+    }
+    return entry.getUserFlagsByMe;
+};
+/**
+ * The current user's own flag succeeded (REQ-016). Their report may leave `hashFlag` unchanged
+ * when other reporters had already set all of their bits, so the answer is known: record `true`
+ * for the `hashFlag` the response carries, or drop the answer when it carries none.
+ */
+const onFlaggedByMe = (user, userId) => {
+    bumpGeneration(userId);
+    if (user === null || user === void 0 ? void 0 : user.hashFlag) {
+        recordFlag(userId, user.hashFlag, true);
+        return;
+    }
+    const dropped = readRecord(userId);
+    dropFromCache(cacheKey(userId), true);
+    if ((dropped === null || dropped === void 0 ? void 0 : dropped.isFlagByMe) === false)
+        notifyObservers(userId);
+};
+/**
+ * The current user's own unflag succeeded (`user.unflag` REQ-010, REQ-016). A per-type unflag can
+ * leave other reports in place, so the answer is dropped, never set to `false`; the next "maybe"
+ * is confirmed again.
+ */
+const onUnflaggedByMe = (userId) => {
+    bumpGeneration(userId);
+    const dropped = readRecord(userId);
+    dropFromCache(cacheKey(userId), true);
+    if ((dropped === null || dropped === void 0 ? void 0 : dropped.isFlagByMe) === false)
+        notifyObservers(userId);
+};
+/** Forgets every in-memory trace of the current user's flag state. Records live in the cache. */
+const resetUserFlagByMe = () => {
+    flagsByMeEntries.clear();
+    inFlight.clear();
+    lastConfirmAt.clear();
+    generations.clear();
+};
+/**
+ * Registered through `setupLoginSubscriptions`. Every confirmed answer belongs to the current
+ * user, so the state is cleared on logout; the records themselves go with the cache, and each
+ * also carries the reporter's id.
+ */
+const userFlagByMeOnLoginHandler = () => {
+    const unsubscribe = onSessionStateChange(state => {
+        if (state === "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */ || state === "terminated" /* Amity.SessionStates.TERMINATED */) {
+            resetUserFlagByMe();
+        }
+    });
+    return () => {
+        unsubscribe();
+        resetUserFlagByMe();
+    };
+};
+/**
+ * Called with the cached user when a recorded answer changes what that user would show, so live
+ * objects and live collections deliver it again (REQ-016, delivery).
+ */
+const onUserFlagConfirmed = (callback) => createEventSubscriber(getActiveClient(), 'user/onUserFlagConfirmed', 'local.user.flagConfirmed', ({ userId }) => {
+    var _a;
+    const user = (_a = pullFromCache(['user', 'get', userId])) === null || _a === void 0 ? void 0 : _a.data;
+    if (user)
+        callback(user);
+});
+
 const userLinkedObject = (user) => {
+    // Captured now, so a user object the app holds never changes after a confirm (REQ-014).
+    const confirmedFlagByMe = readConfirmedFlag(user.userId, user.hashFlag);
     return Object.assign(Object.assign({}, user), { get avatar() {
             var _a;
             if (!user.avatarFileId)
-                return undefined;
-            const avatar = (_a = pullFromCache([
-                'file',
-                'get',
-                `${user.avatarFileId}`,
-            ])) === null || _a === void 0 ? void 0 : _a.data;
+                return null;
+            const avatar = (_a = pullFromCache(['file', 'get', user.avatarFileId])) === null || _a === void 0 ? void 0 : _a.data;
+            if (!avatar)
+                return null;
             return avatar;
-        } });
+        },
+        get isFlaggedByMe() {
+            // Bloom test on this object's hashFlag: "definitely not" is exact and sends nothing.
+            // "Maybe" returns the answer confirmed for this hashFlag, or true while one background
+            // confirm runs (REQ-011, REQ-016). Never throws.
+            return isFlaggedByMeFor(user, confirmedFlagByMe);
+        }, 
+        /* begin_public_function
+          id: user.get_flags_by_me
+        */
+        getUserFlagsByMe: getUserFlagsByMeFor(user) });
 };
 
 /* begin_public_function
@@ -2076,13 +2530,13 @@ class NetworkActivitiesWatcher {
         this._listener.clear();
     }
 }
-let instance$b;
+let instance$a;
 var NetworkActivitiesWatcher$1 = {
     getInstance: () => {
-        if (!instance$b) {
-            instance$b = new NetworkActivitiesWatcher();
+        if (!instance$a) {
+            instance$a = new NetworkActivitiesWatcher();
         }
-        return instance$b;
+        return instance$a;
     },
 };
 
@@ -2266,54 +2720,6 @@ const createHttpTransport = (endpoint) => {
     return instance;
 };
 
-class SessionWatcher {
-    constructor() {
-        this._sessionState = "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */;
-        this._listener = new Map();
-    }
-    onSessionStateChange(callback) {
-        this._listener.set(callback, callback);
-        return () => {
-            this._listener.delete(callback);
-        };
-    }
-    setSessionState(state, reason) {
-        if (this._sessionState === state)
-            return;
-        this._sessionState = state;
-        this._listener.forEach(cb => cb(state, reason));
-    }
-    destroy() {
-        this._listener.clear();
-    }
-}
-let instance$a;
-var SessionWatcher$1 = {
-    getInstance: () => {
-        if (!instance$a) {
-            instance$a = new SessionWatcher();
-        }
-        return instance$a;
-    },
-};
-
-/**
- * ```js
- * import { onSessionStateChange } from '@amityco/ts-sdk'
- * const dispose = onSessionStateChange((state: Amity.SessionStates) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Client} has a session state change
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Client Events
- */
-const onSessionStateChange = (callback) => SessionWatcher$1.getInstance().onSessionStateChange(callback);
-
 const TOPICS = {
     [AmityAutoSubscription.NETWORK]: [getNetworkTopic],
     [AmityAutoSubscription.CHAT]: [
@@ -2886,7 +3292,8 @@ const convertRawMembershipToMembership = (member) => {
             if (!userCache) {
                 return undefined;
             }
-            return userCache;
+            // Every user the SDK hands out is a linked object (isFlaggedByMe, getUserFlagsByMe, avatar).
+            return userLinkedObject(userCache);
         } });
 };
 /**
@@ -2920,7 +3327,7 @@ const withUser = (member, userIdProp = 'userId', userProp = 'user') => {
             if (!userCache) {
                 return undefined;
             }
-            return userCache;
+            return userLinkedObject(userCache);
         } }, member);
 };
 /**
@@ -3074,12 +3481,19 @@ const getSubChannelMessagePreview = (subChannelId) => {
 };
 
 const getSubChannelMessagePreviewWithUser = (subChannel) => {
-    var _a;
     const messagePreview = subChannel.messagePreviewId
         ? getSubChannelMessagePreview(subChannel.subChannelId)
         : null;
     const messagePreviewWithUser = messagePreview
-        ? Object.assign(Object.assign({}, messagePreview), { user: (_a = pullFromCache(['user', 'get', messagePreview === null || messagePreview === void 0 ? void 0 : messagePreview.creatorId])) === null || _a === void 0 ? void 0 : _a.data }) : null;
+        ? Object.assign(Object.assign({}, messagePreview), { user: (() => {
+                var _a;
+                const internalUser = (_a = pullFromCache([
+                    'user',
+                    'get',
+                    messagePreview === null || messagePreview === void 0 ? void 0 : messagePreview.creatorId,
+                ])) === null || _a === void 0 ? void 0 : _a.data;
+                return internalUser ? userLinkedObject(internalUser) : undefined;
+            })() }) : null;
     return Object.assign(Object.assign({}, subChannel), { messagePreview: messagePreviewWithUser });
 };
 
@@ -8066,6 +8480,140 @@ const postCommentCountEngineOnLoginHandler = () => onSessionStateChange(state =>
     }
 });
 
+const BOTH_FIELDS = { lastActivity: true, lastMessageAt: true };
+/**
+ * The channel cache is keyed by `channelInternalId`, but a message names its
+ * channel by whichever id the producer had: the raw MQTT payload carries the
+ * internal id, a converted `Amity.InternalMessage` carries the public id, and
+ * the optimistic message carries the sub-channel's `channelId`. Try the direct
+ * key first, then match any of the three ids.
+ */
+const findCachedChannel = (channelId) => {
+    var _a, _b, _c;
+    const direct = (_a = pullFromCache(['channel', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
+    if (direct)
+        return direct;
+    return (_c = (_b = queryCache(['channel', 'get'])) === null || _b === void 0 ? void 0 : _b.find(({ data }) => data.channelInternalId === channelId ||
+        data.channelId === channelId ||
+        data.channelPublicId === channelId)) === null || _c === void 0 ? void 0 : _c.data;
+};
+const isNewer = (stored, at) => !stored || convertDateStringToTimestamp(stored) < convertDateStringToTimestamp(at);
+const isSameInstant = (stored, at) => !!stored && convertDateStringToTimestamp(stored) === convertDateStringToTimestamp(at);
+/** Pushes the changed fields in one write and emits one `local.channel.updated`. */
+const commit = (channel, changes) => {
+    if (Object.keys(changes).length === 0)
+        return false;
+    const updated = shallowClone(channel, changes);
+    // Write back under the key the cache actually uses (the resolver key), not
+    // under `channel.channelId`, which can differ from `channelInternalId`.
+    pushToCache(['channel', 'get', getResolver('channel')(updated)], updated);
+    fireEvent('local.channel.updated', {
+        channels: [updated],
+        channelUsers: [],
+        users: [],
+        files: [],
+    });
+    return true;
+};
+/**
+ * Single owner of every local write to a channel's ordering timestamps,
+ * `lastActivity` and `lastMessageAt` (ChannelActivityService v1).
+ *
+ * - Monotonic per field: a field moves only when `at` is newer than the stored
+ *   value (or the stored value is `null`), so a late or replayed event never
+ *   moves a channel down the list.
+ * - One write: both fields are read, compared and pushed in a single cache
+ *   update, followed by one `local.channel.updated` event so every open channel
+ *   collection re-sorts once.
+ * - Server channel payloads never go through here; they overwrite unguarded.
+ *
+ * @returns `true` when at least one field moved
+ * @category private
+ */
+const updateChannelActivityTimestamps = (channelId, at, fields = BOTH_FIELDS) => {
+    const client = getActiveClient();
+    if (!client.cache || !channelId || !at)
+        return false;
+    const channel = findCachedChannel(channelId);
+    if (!channel)
+        return false;
+    const changes = {};
+    if (fields.lastActivity && isNewer(channel.lastActivity, at))
+        changes.lastActivity = at;
+    if (fields.lastMessageAt && isNewer(channel.lastMessageAt, at))
+        changes.lastMessageAt = at;
+    return commit(channel, changes);
+};
+/**
+ * Local correction for the current user's own send (ChannelActivityService v1
+ * REQ-009, Trigger Matrix row 1b). Once the server confirms the message, each
+ * field that still holds the device-clock `localAt` written at send time is
+ * replaced by the server's `serverAt`, even when that is older. A field a newer
+ * message has already moved is left alone. One write, one change notification,
+ * nothing when neither field still holds `localAt`.
+ *
+ * @returns `true` when at least one field was replaced
+ * @category private
+ */
+const confirmOwnMessage = (channelId, localAt, serverAt) => {
+    const client = getActiveClient();
+    if (!client.cache || !channelId || !localAt || !serverAt)
+        return false;
+    if (isSameInstant(localAt, serverAt))
+        return false;
+    const channel = findCachedChannel(channelId);
+    if (!channel)
+        return false;
+    const changes = {};
+    if (isSameInstant(channel.lastActivity, localAt))
+        changes.lastActivity = serverAt;
+    if (isSameInstant(channel.lastMessageAt, localAt))
+        changes.lastMessageAt = serverAt;
+    return commit(channel, changes);
+};
+
+/**
+ * Session-wide owner of the local `lastActivity` / `lastMessageAt` updates
+ * (ChannelActivityService v1, Web migration rows W1 – W5).
+ *
+ * Registered once per session from `setupLoginSubscriptions` and
+ * `resumeSession`, so the update runs whether or not a channel collection is
+ * open, and exactly once per message however many collections are open.
+ *
+ * It listens to the raw events rather than `onMessageCreatedMqtt`, so it does
+ * not duplicate that subscriber's side effects (mark-read, unread recount).
+ *
+ * @category private
+ */
+const channelActivityOnLoginHandler = () => {
+    const client = getActiveClient();
+    const disposers = [
+        // Any user's new message, in any message feed of the channel. The raw
+        // payload's `channelId` is the channel's internal id.
+        createEventSubscriber(client, 'channelActivity', 'message.created', payload => {
+            payload.messages.forEach(message => {
+                updateChannelActivityTimestamps(message.channelId, message.createdAt);
+            });
+        }),
+        // The current user's own send fires this three times: with the optimistic
+        // message at send time (Syncing), on the create response (Synced), and on
+        // failure (Error). The device-clock time of the Syncing / Error fires was
+        // already applied synchronously in createMessageOptimistic, and replaying it
+        // here could undo the server correction made on the response
+        // (confirmOwnMessage). Only the server-confirmed fire goes through the guard.
+        createEventSubscriber(client, 'channelActivity', 'local.message.created', payload => {
+            payload.messages.forEach(message => {
+                if (message.syncState !== "synced" /* Amity.SyncState.Synced */)
+                    return;
+                updateChannelActivityTimestamps(message.channelId, message.createdAt);
+            });
+        }),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
 const EVENTS = [
     'disconnected',
     'error',
@@ -8255,7 +8803,7 @@ const setupLoginSubscriptions = (unsubWatcher) => {
     // 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 not be reset to zero
-    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler(), blockedUserSyncEngineOnLoginHandler(), blockingUserSyncEngineOnLoginHandler(), blockRealtimeOnLoginHandler(), resetAutoSubscriptionsOnLogout(), CursorController.clearOnLogout(), postCommentCountEngineOnLoginHandler());
+    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler(), blockedUserSyncEngineOnLoginHandler(), blockingUserSyncEngineOnLoginHandler(), blockRealtimeOnLoginHandler(), resetAutoSubscriptionsOnLogout(), CursorController.clearOnLogout(), postCommentCountEngineOnLoginHandler(), channelActivityOnLoginHandler(), userFlagByMeOnLoginHandler());
     if (client.useLegacyUnreadCount) {
         subscriptions.push(readReceiptSyncEngineOnLoginHandler());
     }
@@ -9516,7 +10064,7 @@ const resumeSession = async (params, sessionHandler, config) => {
         // 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 not be reset to zero
-        onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler());
+        onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), channelActivityOnLoginHandler());
         if (client.useLegacyUnreadCount) {
             subscriptions$1.push(readReceiptSyncEngineOnLoginHandler());
         }
@@ -11808,7 +12356,7 @@ const prepareCommunityPayload = (rawPayload) => {
     // map users with community
     const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
         const user = internalUsers.find(user => user.userId === communityUser.userId);
-        return Object.assign(Object.assign({}, communityUser), { user });
+        return Object.assign(Object.assign({}, communityUser), { user: user ? userLinkedObject(user) : undefined });
     });
     const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
     return Object.assign(Object.assign({}, rawPayload), { users: rawPayload.users.map(convertRawUserToInternalUser), communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
@@ -11825,7 +12373,7 @@ const prepareCommunityMembershipPayload = (rawPayload) => {
     // map users with community
     const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
         const user = rawPayload.users.find(user => user.userId === communityUser.userId);
-        return Object.assign(Object.assign({}, communityUser), { user });
+        return Object.assign(Object.assign({}, communityUser), { user: user ? userLinkedObject(convertRawUserToInternalUser(user)) : undefined });
     });
     const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
     return Object.assign(Object.assign({}, rawPayload), { communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
@@ -13475,7 +14023,7 @@ const getWatchSessionStorage = () => {
     return storageInstance;
 };
 
-const privateKey = "MIIEpQIBAAKCAQEAwAEc/oZgYIvKSUG/C3mONYLR4ZPgAjMEX4bJ+xqqakUDRtqlNO+eZs2blQ1Ko0DBkqPExyQezvjibH5W2UZBV5RaBTlTcNVKTToMBEGesAfaEcM3qUyQHxdbFYZv6P4sb14dcwxTQ8usmaV8ooiR1Fcaso5ZWYcZ8Hb46FbQ7OoVumsBtPWwfZ4f003o5VCl6AIM6lcLv9UDLlFVYhE+PeXpRHtfWlGqxMvqC9oinlwhL6nWv6VjQXW4nhcib72dPBzfHT7k/PMKto2SxALYdb68ENiAGuJLWi3AUHSyYCJK2w7wIlWfJUAI0v26ub10IpExr6D5QuW2577jjP93iwIDAQABAoIBAFWfqXhwIIatkFY+9Z1+ZcbDQimgsmMIsUiQaX6Lk7e0cxOj6czDlxYtVtaPiNtow2pLkjNkjkCqiP7tEHnwdK9DvylZOTa2R15NJpK3WLcTqVIGhsn/FL5owfvFah6zSsmXZParZm5zY9NZE03ALZhOB9/cz0e3kf/EbpfeL2mW7MApyiUt5i09ycchroOpcWp73ipIxvgigtZyUGFmsQicWhUs28F0D7w4Qfk76yG3nqXeb+BAMhCaIaa/k/aAxhiZG/ygEQWQrcC8gfe+jyicMAQPDEVS9YuUMGsLjIjKuVLZzp2xirQnhc2i2zVNEIvG6soprPOBEMQugzrtX5ECgYEA3b7KAbBIbDl1e4ZSCWhHdHkiWVZHaopsR/LhqDDNhXjWjq3AesgV6k0j9EdziMn/HmmOso0bz99GTV3JZf4A9ztTLumJlkHbdVtlgOqSjrFLj12rH9KXTheyIhWSpUmm8+WB1xasFbqpvJaGo7F3pd2Fqj1XR4mp5BO7c/t7LJ0CgYEA3aouEzXQ9THRKYocdfY69EI1Il1t/d/RSqqd9BxEjxBgxkM13ZiYIn/R4WW/nCUrlmhxG44Aa2Gob4Ahfsui2xKTg/g/3Zk/rAxAEGkfOLGoenaJMD41fH4wUq3FRYwkvnaMb9Hd6f/TlBHslIRa2NN58bSBGJCyBP2b59+2+EcCgYEAixDVRXvV37GlYUOa/XVdosk5Zoe6oDGRuQm0xbNdoUBoZvDHDvme7ONWEiQha/8qtVsD+CyQ7awcPfb8kK9c0bBt+bTS6d4BkTcxkEkMgtrkBVR8Nqfu5jXsLH4VCv4G61zbMhZw8+ut+az5YX2yCN7Frj9sFlxapMRPQmzMEe0CgYEAumsAzM8ZqNv4mAK65Mnr0rhLj1cbxcKRdUYACOgtEFQpzxN/HZnTeFAe5nx3pI3uFlRHq3DFEYnT6dHMWaJQmAULYpVIwMi9L6gtyJ9fzoI6uqMtxRDMUqKdaSsTGOY/kJ6KhQ/unXi1K3XXjR+yd1+C0q+HUm1+CYxvrZYLfskCgYEArsEy+IQOiqniJ0NE2vVUF+UK/IRZaic9YKcpov5Ot7Vvzm/MnnW4N1ljVskocETBWMmPUvNSExVjPebi+rxd8fa5kY8BJScPTzMFbunZn/wjtGdcM10qdlVQ9doG61A/9P3ezFKCfS4AvF/H/59LcSx2Bh28fp3/efiVIOpVd4Y=";
+const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDHo80SecH7FuF2\nhFYnb+l26/VN8UMLXAQFLnxciNTEwkGVFMpdezlH8rU2HtUJL4RETogbAOLVY0XM\njs6sPn8G1nALmh9qeDpUtVqFOVtBHxEZ910TLOtQiunjqJKO5nWdqZ71EC3OFluR\niGQkO84BiIFbv37ub7xl3S8XarbtKoLcyVpkDHi+1wx1pgCAn6gtBUgckPL5NR8j\nLseabl3HAXQfhTCKo4tmOFM2Dxwl1IUMmIJrJg/aIU/U0tj/1Eoo7mG0JcNWX19l\nW3EecCbi0ncCJOrkUdwlBrcjaMayaX/ubEwyUeTGiLdyc4L3GRLHjyK8xgVNXRMH\nbZWJ2a5NAgMBAAECggEASxuE+35zTFO/XydKgmvIGcWL9FbgMlXb7Vcf0nBoG945\nbiz0NVc2paraIhJXc608xbYF3qLmtAE1MVBI0ORyRdBHNxY024l/6H6SH60Ed+uI\nM4ysp5ourY6Vj+DLwpdRiI9YDjqYAQDIUmhNxJP7XPhOMoZI6st+xZQBM34ic/bv\nAMSJm9OZphSp3+qXVkFZztr2mxD2EZSJJLYxi8BCdgM2qhazalbcJ6zDKHCZWVWm\n8RRxDGldyMb/237JxETzP40tAlzOZDmBAbUgEnurDJ93RVDIE3rbZUshwgeQd18a\nem096mWgvB1AIKYgsTAR3pw+V19YWAjq/glP6fz8wQKBgQD/oQq+ukKF0PRgBeM5\ngeTjSwsdGppQLmf5ndujvoiz/TpdjDEPu6R8kigQr1rG2t4K/yfdZoI8RdmJD1al\n3Q7N9hofooSy4rj6E3txzWZCHJjHad2cnCp/O26HiReGAl7wTcfTmNdiFHhZQzm5\nJBkvWAiwuvQMNfEbnXxw6/vIDwKBgQDH7fX8gsc77JLvAWgp1MaQN/sbqVb6JeT1\nFQfR8E/WFCSmzQBtNzd5KgYuCeelwr/8DyYytvN2BzCYZXp73gI1jF3YlW5jVn74\nOY6TwQ095digwo6Z0yuxopdIOApKgAkL9PRKgNrqAf3NAyMua6lOGifzjDojC3KU\nfylQmxMn4wKBgHp2B9O/H0dEBw5JQ8W0+JX6yWQz7mEjGiR2/1W+XXb8hQ1zr709\nw1r6Gb+EghRpnZ3fBpYGGbYOMFx8wKHM+N6qW3F0ReX8v2juFGE8aRSa5oYBrWzt\nU16Idjbv8hj84cZ1PJmdyvDtpYn9rpWHOZl4rxEbPvbqkIsOMyNVqdT5AoGAOSge\nmwIIU2le2FVeohbibXiToWTYKMuMmURZ5/r72AgKMmWJKbAPe+Q3wBG01/7FRBpQ\noU8Ma0HC8s6QJbliiEyIx9JwrJWd1vkdecBHONrtA4ibm/5zD2WcOllLF+FitLhi\n3qnX6+6F0IaFGFBPJrTzlv0P4dTz/OAdv52V7GECgYEA2TttOKBAqWllgOaZOkql\nLVMJVmgR7s6tLi1+cEP8ZcapV9aRbRzTAKXm4f8AEhtlG9F9kCOvHYCYGi6JaiWJ\nZkHjeex3T+eE6Di6y5Bm/Ift5jtVhJ4jCVwHOKTMej79NPUFTJfv8hCo29haBDv6\nRXFrv+T21KCcw8k3sJeJWWQ=\n-----END PRIVATE KEY-----";
 /*
  * The crypto algorithm used for importing key and signing string
  */
@@ -15250,7 +15798,7 @@ const updateUser = async (userId, patch) => {
         ingestInCache(payload, { cachedAt });
     fireEvent('user.updated', data);
     return {
-        data: payload.users.find(user => user.userId === userId),
+        data: userLinkedObject(payload.users.find(user => user.userId === userId)),
         cachedAt,
     };
 };
@@ -15301,8 +15849,11 @@ const flagUser = async (userId, options) => {
     if (client.cache) {
         ingestInCache(payload);
     }
+    const flagged = (_a = payload.users.find(user => user.userId === userId)) !== null && _a !== void 0 ? _a : payload.users[0];
+    // The caller's own report may leave hashFlag unchanged; record that they flagged (REQ-016).
+    onFlaggedByMe(flagged, userId);
     fireEvent('user.flagged', data);
-    return (_a = payload.users.find(user => user.userId === userId)) !== null && _a !== void 0 ? _a : payload.users[0];
+    return userLinkedObject(flagged);
 };
 /* end_public_function */
 
@@ -15322,14 +15873,18 @@ const submitUserReport = async (apiName, userId, body) => {
     if (client.cache) {
         ingestInCache(payload);
     }
+    const flagged = (_a = payload.users.find(user => user.userId === userId)) !== null && _a !== void 0 ? _a : payload.users[0];
+    // The caller's own report may leave hashFlag unchanged; record that they flagged (REQ-016).
+    onFlaggedByMe(flagged, userId);
     fireEvent('user.flagged', data);
-    return (_a = payload.users.find(user => user.userId === userId)) !== null && _a !== void 0 ? _a : payload.users[0];
+    return userLinkedObject(flagged);
 };
 
 /** Maximum `comment` length, in string length units, after trimming. */
 const USER_REPORT_COMMENT_MAX_LENGTH = 300;
 const PROFILE_FIELDS = Object.values(UserProfileFieldEnum);
 const BEHAVIOR_REASONS = Object.values(ContentFlagReasonEnum);
+const REPORT_TYPE_FILTERS = Object.values(UserReportTypeFilterEnum);
 const assertOptionsObject = (apiName, options, shape) => {
     if (typeof options !== 'object' || options === null || Array.isArray(options)) {
         throw new ASCInvalidParameterError(`${apiName}: expected an options object \`${shape}\``);
@@ -15389,6 +15944,28 @@ const toUserBehaviorReportBody = (options) => {
     }
     return withComment({ reportType: 'behavior', reason }, normalizeUserReportComment(apiName, comment));
 };
+/**
+ * Validates the optional `{ reportType? }` of `unflagUser` and builds its query parameters.
+ * Returns `undefined` when no `reportType` is given, so the request carries no query string
+ * and withdraws every report the caller filed on the user. The server validates the value
+ * too (422); this local check only saves the round-trip for the string alias, which admits
+ * raw strings. Untyped callers can pass anything at runtime, so nothing is trusted from the
+ * declared type.
+ *
+ * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when the options are malformed or `reportType` is unknown
+ */
+const toUserReportTypeFilter = (options) => {
+    if (options === undefined)
+        return undefined;
+    const apiName = 'unflagUser';
+    const { reportType } = assertOptionsObject(apiName, options, '{ reportType? }');
+    if (reportType === undefined)
+        return undefined;
+    if (typeof reportType !== 'string' || !REPORT_TYPE_FILTERS.includes(reportType)) {
+        throw new ASCInvalidParameterError(`${apiName}: \`reportType\` must be a \`UserReportTypeFilterEnum\` value`);
+    }
+    return { reportType: reportType };
+};
 
 /* begin_public_function
   id: user.flag_profile
@@ -15461,24 +16038,53 @@ const flagUserBehavior = async (userId, options) => submitUserReport('flagUserBe
 */
 /**
  * ```js
- * import { UserRepository } from '@amityco/ts-sdk'
- * const unflagged = await UserRepository.unflagUser('post', postId)
+ * import { UserRepository, UserReportTypeFilterEnum } from '@amityco/ts-sdk'
+ *
+ * // Withdraw every report I filed on the user.
+ * const unflagged = await UserRepository.unflagUser('userId')
+ *
+ * // Withdraw only my behavior report; my other reports on the user stay.
+ * await UserRepository.unflagUser('userId', { reportType: UserReportTypeFilterEnum.BEHAVIOR })
+ *
+ * // Withdraw only my typeless (legacy) report.
+ * await UserRepository.unflagUser('userId', { reportType: UserReportTypeFilterEnum.UNTYPED })
  * ```
  *
+ * Withdraws the caller's reports on a user. Without `reportType` every report the caller
+ * filed on that user is withdrawn, as before. With `reportType` only the caller's report
+ * of that type is withdrawn; the caller's other reports and other users' reports are
+ * untouched. Withdrawing a report that does not exist succeeds and changes nothing.
+ *
+ * The returned user is persisted to the cache, so its `hashFlag` says whether the caller
+ * may still hold a report on the user. Do not flip a local "flagged by me" flag to `false`
+ * after a per-type withdrawal; observe the user and read `isFlaggedByMe`, or call
+ * `user.getUserFlagsByMe()` for the remaining per-type state (`flags`). The SDK drops the
+ * answer it confirmed for this user, so the next "maybe" is confirmed again.
+ *
+ * Sends `DELETE /api/v4/me/flags/:userId`, with `?reportType=<type>` when one is given.
+ *
  * @param userId The ID of the user to unflag
- * @returns the deleted report result
+ * @param options Optional; `reportType` selects a single report to withdraw. For a report that `user.getUserFlagsByMe()` lists with `reportType: null`, pass `UserReportTypeFilterEnum.UNTYPED`
+ * @returns `true` once the server has processed the withdrawal
+ * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when `reportType` is not a `UserReportTypeFilterEnum` value, before any request is made
  *
  * @category User API
  * @async
  * */
-const unflagUser = async (userId) => {
-    const client = getActiveClient();
-    client.log('user/unflag', userId);
-    const { data } = await client.http.delete(`/api/v4/me/flags/${encodeURIComponent(userId)}`);
+const unflagUser = async (userId, options) => {
+    const client = getActiveClient();
+    client.log('user/unflag', { userId, options });
+    const params = toUserReportTypeFilter(options);
+    const url = `/api/v4/me/flags/${encodeURIComponent(userId)}`;
+    const { data } = params
+        ? await client.http.delete(url, { params })
+        : await client.http.delete(url);
     const payload = prepareUserPayload(data);
     if (client.cache) {
         ingestInCache(payload);
     }
+    // Drop the confirmed answer; never set it to false: other reports may remain (REQ-010).
+    onUnflaggedByMe(userId);
     fireEvent('user.unflagged', data);
     return !!payload;
 };
@@ -15490,11 +16096,19 @@ const unflagUser = async (userId) => {
 /**
  * ```js
  * import { UserRepository } from '@amityco/ts-sdk'
- * const isFlagged = await UserRepository.isUserFlaggedByMe(postId)
+ * const isFlagged = await UserRepository.isUserFlaggedByMe(userId)
  * ```
  *
- * @param userId The ID of the thing to check a report to.
- * @returns `true` if the report is created by me, `false` if doesn't.
+ * Whether the current user has reported a user. Sends one request per call and caches
+ * nothing.
+ *
+ * @deprecated Read `user.isFlaggedByMe` on an {@link Amity.User} for a yes/no hint that
+ * usually needs no request, and call `user.getUserFlagsByMe()` for the exact answer with the
+ * caller's reports by type. Observe the user with `UserRepository.getUser(userId, callback)`
+ * to follow a flag or unflag.
+ *
+ * @param userId The ID of the user to check
+ * @returns `true` if the current user has reported the user, `false` if not
  *
  * @category Report API
  * @async
@@ -15502,7 +16116,7 @@ const unflagUser = async (userId) => {
 const isUserFlaggedByMe = async (userId) => {
     const client = getActiveClient();
     client.log('user/isUserFlaggedByMe', userId);
-    const { data: { isFlagByMe }, } = await client.http.get(`/api/v3/users/${userId}/isFlagByMe`);
+    const { isFlagByMe } = await getFlagsByMe(userId);
     return isFlagByMe;
 };
 /* end_public_function */
@@ -15742,7 +16356,7 @@ const getUser = (userId, callback) => {
     const reactor = (response) => {
         return callback(Object.assign(Object.assign({}, response), { data: response.data ? LinkedObject.user(response.data) : response.data }));
     };
-    return liveObject(userId, reactor, 'userId', getUser$1, [
+    const unsubscribeUser = liveObject(userId, reactor, 'userId', getUser$1, [
         onUserFetched,
         onUserUpdated,
         onUserDeleted$2,
@@ -15750,19 +16364,28 @@ const getUser = (userId, callback) => {
         onUserUnflagged,
         onUserFlagCleared,
     ]);
+    // A confirmed flag answer leaves the cached user row unchanged, so the live object's own
+    // dedupe would drop it. Deliver the re-linked user directly (user.check_flag_by_me REQ-016).
+    const unsubscribeFlag = onUserFlagConfirmed(user => {
+        if (user.userId !== userId)
+            return;
+        callback({ data: LinkedObject.user(user), loading: false, origin: 'event' });
+    });
+    return () => {
+        unsubscribeUser();
+        unsubscribeFlag();
+    };
 };
 /* end_public_function */
 
-class UserPaginationController extends PaginationController {
-    async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
-        const options = token ? { token } : { limit };
-        const { data: queryResponse } = await this.http.get(`/api/v3/users`, {
-            params: Object.assign(Object.assign({}, params), { options, isDeleted: false }),
-        });
-        return queryResponse;
-    }
-}
+var EnumUserActions;
+(function (EnumUserActions) {
+    EnumUserActions["OnUserDeleted"] = "onUserDeleted";
+    EnumUserActions["OnUserUpdated"] = "onUserUpdated";
+    EnumUserActions["OnUserFlagged"] = "onUserFlagged";
+    EnumUserActions["OnUserUnflagged"] = "onUserUnflagged";
+    EnumUserActions["OnUserFlagCleared"] = "onUserFlagCleared";
+})(EnumUserActions || (EnumUserActions = {}));
 
 class UserQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload) {
@@ -15810,14 +16433,16 @@ class UserQueryStreamController extends QueryStreamController {
     }
 }
 
-var EnumUserActions;
-(function (EnumUserActions) {
-    EnumUserActions["OnUserDeleted"] = "onUserDeleted";
-    EnumUserActions["OnUserUpdated"] = "onUserUpdated";
-    EnumUserActions["OnUserFlagged"] = "onUserFlagged";
-    EnumUserActions["OnUserUnflagged"] = "onUserUnflagged";
-    EnumUserActions["OnUserFlagCleared"] = "onUserFlagCleared";
-})(EnumUserActions || (EnumUserActions = {}));
+class UserPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v3/users`, {
+            params: Object.assign(Object.assign({}, params), { options, isDeleted: false }),
+        });
+        return queryResponse;
+    }
+}
 
 class UserLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
@@ -15847,13 +16472,24 @@ class UserLiveCollectionController extends LiveCollectionController {
         this.queryStreamController.appendToQueryStream(response, direction, refresh);
     }
     startSubscription() {
-        return this.queryStreamController.subscribeRTE([
-            { fn: onUserDeleted$2, action: EnumUserActions.OnUserDeleted },
-            { fn: onUserUpdated, action: EnumUserActions.OnUserUpdated },
-            { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
-            { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
-            { fn: onUserFlagCleared, action: EnumUserActions.OnUserFlagCleared },
-        ]);
+        return [
+            ...this.queryStreamController.subscribeRTE([
+                { fn: onUserDeleted$2, action: EnumUserActions.OnUserDeleted },
+                { fn: onUserUpdated, action: EnumUserActions.OnUserUpdated },
+                { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
+                { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
+                { fn: onUserFlagCleared, action: EnumUserActions.OnUserFlagCleared },
+            ]),
+            // A confirmed flag answer changes isFlaggedByMe on a listed user without changing its
+            // cache row (user.check_flag_by_me REQ-016). Re-link only collections that hold it.
+            onUserFlagConfirmed(user => {
+                var _a;
+                const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                if (!(collection === null || collection === void 0 ? void 0 : collection.data.includes(user.userId)))
+                    return;
+                this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+            }),
+        ];
     }
     notifyChange({ origin, loading, error }) {
         var _a, _b;
@@ -15934,16 +16570,17 @@ const getUsers = (params, callback, config) => {
 };
 /* end_public_function */
 
-class BlockedUserPaginationController extends PaginationController {
-    async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
-        const options = token ? { token } : { limit };
-        const { data: queryResponse } = await this.http.get('/api/v4/me/user-blocks', {
-            params: Object.assign(Object.assign({}, params), { options, isDeleted: false }),
-        });
-        return queryResponse;
+const convertEventPayload = (eventHandler, sourceModelProp, destinationDomain) => (callback) => eventHandler(sourceModel => {
+    var _a;
+    if (!sourceModel) {
+        return sourceModel;
     }
-}
+    const cacheKey = [destinationDomain, 'get', `${sourceModel[sourceModelProp]}`];
+    const model = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+    if (!model)
+        return;
+    return callback(model);
+});
 
 var EnumBlockActions;
 (function (EnumBlockActions) {
@@ -15999,17 +16636,16 @@ class BlockedUserQueryStreamController extends QueryStreamController {
     }
 }
 
-const convertEventPayload = (eventHandler, sourceModelProp, destinationDomain) => (callback) => eventHandler(sourceModel => {
-    var _a;
-    if (!sourceModel) {
-        return sourceModel;
+class BlockedUserPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get('/api/v4/me/user-blocks', {
+            params: Object.assign(Object.assign({}, params), { options, isDeleted: false }),
+        });
+        return queryResponse;
     }
-    const cacheKey = [destinationDomain, 'get', `${sourceModel[sourceModelProp]}`];
-    const model = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-    if (!model)
-        return;
-    return callback(model);
-});
+}
 
 class BlockedUserLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
@@ -16319,17 +16955,6 @@ const getBlockingUsers = (callback) => {
 };
 /* end_public_function */
 
-class SearchUserPaginationController extends PaginationController {
-    async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, displayName } = queryParams, params = __rest(queryParams, ["limit", "displayName"]);
-        const options = token ? { token } : { limit };
-        const { data: queryResponse } = await this.http.get(`/api/v3/users`, {
-            params: Object.assign(Object.assign({}, params), { keyword: displayName, options, isDeleted: false }),
-        });
-        return queryResponse;
-    }
-}
-
 class SearchUserQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload) {
         super(query, cacheKey);
@@ -16376,6 +17001,17 @@ class SearchUserQueryStreamController extends QueryStreamController {
     }
 }
 
+class SearchUserPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, displayName } = queryParams, params = __rest(queryParams, ["limit", "displayName"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v3/users`, {
+            params: Object.assign(Object.assign({}, params), { keyword: displayName, options, isDeleted: false }),
+        });
+        return queryResponse;
+    }
+}
+
 class SearchUserLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
         var _a;
@@ -16405,13 +17041,24 @@ class SearchUserLiveCollectionController extends LiveCollectionController {
         this.queryStreamController.appendToQueryStream(response, direction, refresh);
     }
     startSubscription() {
-        return this.queryStreamController.subscribeRTE([
-            { fn: onUserDeleted$2, action: EnumUserActions.OnUserDeleted },
-            { fn: onUserUpdated, action: EnumUserActions.OnUserUpdated },
-            { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
-            { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
-            { fn: onUserFlagCleared, action: EnumUserActions.OnUserFlagCleared },
-        ]);
+        return [
+            ...this.queryStreamController.subscribeRTE([
+                { fn: onUserDeleted$2, action: EnumUserActions.OnUserDeleted },
+                { fn: onUserUpdated, action: EnumUserActions.OnUserUpdated },
+                { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
+                { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
+                { fn: onUserFlagCleared, action: EnumUserActions.OnUserFlagCleared },
+            ]),
+            // A confirmed flag answer changes isFlaggedByMe on a listed user without changing its
+            // cache row (user.check_flag_by_me REQ-016). Re-link only collections that hold it.
+            onUserFlagConfirmed(user => {
+                var _a;
+                const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                if (!(collection === null || collection === void 0 ? void 0 : collection.data.includes(user.userId)))
+                    return;
+                this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+            }),
+        ];
     }
     notifyChange({ origin, loading, error }) {
         var _a, _b;
@@ -17242,7 +17889,7 @@ const preparePostPayload = (payload) => {
     // map users with community
     const mappedCommunityUsers = postPayload.communityUsers.map(communityUser => {
         const user = postPayload.users.find(user => user.userId === communityUser.userId);
-        return Object.assign(Object.assign({}, communityUser), { user });
+        return Object.assign(Object.assign({}, communityUser), { user: user ? userLinkedObject(convertRawUserToInternalUser(user)) : undefined });
     });
     const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
     let mappedNewStream = [];
@@ -19053,7 +19700,8 @@ const getPostReport = async ({ client, referenceId, }) => {
 };
 const getUserReport = async ({ client, referenceId, }) => {
     var _a;
-    const { data } = await client.http.get(`/api/v3/users/${referenceId}/isflagbyme`);
+    // v3 isFlagByMe is deprecated by the backend; v4 answers the same boolean plus the caller's flags.
+    const { data } = await client.http.get(`/api/v4/users/${encodeURIComponent(referenceId)}/isFlagByMe`);
     const { result, isFlagByMe } = data !== null && data !== void 0 ? data : {};
     return (_a = result !== null && result !== void 0 ? result : isFlagByMe) !== null && _a !== void 0 ? _a : false;
 };
@@ -19670,7 +20318,7 @@ const getLocalId = () => `LOCAL_${uuid()}`;
 // FIXME: temp solution
 let uniqueId;
 const createMessageOptimistic = (bundle) => {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const client = getActiveClient();
     if (!client.cache)
         return;
@@ -19701,9 +20349,20 @@ const createMessageOptimistic = (bundle) => {
     }
     // as reused to update created and updated time, which should be the same
     const createdTime = new Date().toISOString();
-    const message = Object.assign({ creatorId: client.userId, creatorPrivateId: getActiveUser()._id, channelSegment: ((_b = subChannel === null || subChannel === void 0 ? void 0 : subChannel.data.messageCount) !== null && _b !== void 0 ? _b : 0) + 1, childrenNumber: 0, createdAt: createdTime, updatedAt: createdTime, syncState: "syncing" /* Amity.SyncState.Syncing */, isDeleted: false }, bundleWithMessageId);
+    const message = Object.assign({ 
+        // The optimistic message must name its channel (public id) so the own-send
+        // update can move lastActivity / lastMessageAt at send time. Take it from the
+        // cached sub-channel; when that is not cached, resolve the sub-channel id
+        // through the channel cache, which for a channel's default sub-channel is
+        // the channel itself (ChannelActivityService migration row I2). A thread or
+        // unknown channel resolves to undefined, as before.
+        channelId: (_b = subChannel === null || subChannel === void 0 ? void 0 : subChannel.data.channelId) !== null && _b !== void 0 ? _b : (_c = findCachedChannel(bundle.subChannelId)) === null || _c === void 0 ? void 0 : _c.channelId, creatorId: client.userId, creatorPrivateId: getActiveUser()._id, channelSegment: ((_d = subChannel === null || subChannel === void 0 ? void 0 : subChannel.data.messageCount) !== null && _d !== void 0 ? _d : 0) + 1, childrenNumber: 0, createdAt: createdTime, updatedAt: createdTime, syncState: "syncing" /* Amity.SyncState.Syncing */, isDeleted: false }, bundleWithMessageId);
     const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
     pushToCache(['message', 'get', message.messageId], message, { cachedAt });
+    // Own-send update (ChannelActivityService row 1): move the channel at send
+    // time, synchronously, so the confirmation on the send response always sees
+    // this value rather than racing the scheduled local event below.
+    updateChannelActivityTimestamps(message.channelId, message.createdAt);
     fireEvent('local.message.created', { messages: [message] });
     return message;
 };
@@ -19743,6 +20402,9 @@ const createMessage = async (bundle) => {
         if (client.cache) {
             ingestInCache(data, { cachedAt });
         }
+        // The own-send update wrote the device-clock createdAt; replace it with the
+        // server's now that the message is confirmed (ChannelActivityService REQ-009).
+        confirmOwnMessage(optimisticData === null || optimisticData === void 0 ? void 0 : optimisticData.channelId, optimisticData === null || optimisticData === void 0 ? void 0 : optimisticData.createdAt, messages[0].createdAt);
         fireEvent('local.message.created', {
             messages: [Object.assign(Object.assign({}, messages[0]), { syncState: "synced" /* Amity.SyncState.Synced */ })],
         });
@@ -22186,6 +22848,9 @@ class ChannelLiveCollectionController extends LiveCollectionController {
             case 'lastCreated':
                 channels = channels.sort(sortByLastCreated);
                 break;
+            case 'lastMessage':
+                channels = channels.sort(sortByLastMessage);
+                break;
             case 'displayName':
                 /*
                  * The server returns channels with empty | null displayName's first before
@@ -22246,9 +22911,8 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                             objectResolverEngine.resolve(message.channelId, "channel" /* Amity.ReferenceType.CHANNEL */);
                         }
                         else {
-                            updateChannelCache(channelCache, {
-                                lastActivity: message.createdAt,
-                            });
+                            // lastActivity / lastMessageAt are moved by channelActivityOnLoginHandler
+                            // (session-wide, monotonic, one write). This listener only re-sorts.
                             callback(message);
                         }
                     });
@@ -22266,9 +22930,7 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                         ])) === null || _a === void 0 ? void 0 : _a.data;
                         if (!cacheData)
                             return;
-                        updateChannelCache(cacheData, {
-                            lastActivity: message.createdAt,
-                        });
+                        // Timestamps are moved by channelActivityOnLoginHandler; only re-sort here.
                         callback(message);
                     });
                 }, 'channelId', 'channel'),
@@ -23006,9 +23668,7 @@ class SearchChannelLiveCollectionController extends LiveCollectionController {
                         ])) === null || _a === void 0 ? void 0 : _a.data;
                         if (!cacheData)
                             return;
-                        updateChannelCache(cacheData, {
-                            lastActivity: message.createdAt,
-                        });
+                        // Timestamps are moved by channelActivityOnLoginHandler; only re-sort here.
                         callback(message);
                     });
                 }, 'channelId', 'channel'),
@@ -23025,9 +23685,7 @@ class SearchChannelLiveCollectionController extends LiveCollectionController {
                         ])) === null || _a === void 0 ? void 0 : _a.data;
                         if (!cacheData)
                             return;
-                        updateChannelCache(cacheData, {
-                            lastActivity: message.createdAt,
-                        });
+                        // Timestamps are moved by channelActivityOnLoginHandler; only re-sort here.
                         callback(message);
                     });
                 }, 'channelId', 'channel'),
@@ -23450,7 +24108,7 @@ const onUserDeleted$1 = (channelId) => (callback) => {
             'get',
             channelUserCacheKey,
         ])) === null || _a === void 0 ? void 0 : _a.data;
-        upsertInCache(['channelUsers', 'get', channelUserCacheKey], Object.assign(Object.assign({}, cacheData), { user }));
+        upsertInCache(['channelUsers', 'get', channelUserCacheKey], Object.assign(Object.assign({}, cacheData), { user: userLinkedObject(user) }));
         const channel = (_b = pullFromCache([
             'channel',
             'get',
@@ -24923,10 +25581,10 @@ const onUserDeleted = (communityId) => (callback) => {
             'get',
             communityUserCacheKey,
         ])) === null || _a === void 0 ? void 0 : _a.data;
-        pushToCache(['communityUsers', 'get', communityUserCacheKey], Object.assign(Object.assign({}, cacheData), { user }));
+        pushToCache(['communityUsers', 'get', communityUserCacheKey], Object.assign(Object.assign({}, cacheData), { user: userLinkedObject(user) }));
         const community = (_b = pullFromCache(['community', 'get', communityId])) === null || _b === void 0 ? void 0 : _b.data;
         callback(community, [
-            Object.assign(Object.assign({}, cacheData), { user }),
+            Object.assign(Object.assign({}, cacheData), { user: userLinkedObject(user) }),
         ]);
     };
     return createEventSubscriber(client, 'user.deleted', 'user.deleted', filter);
@@ -37529,4 +38187,4 @@ class AmityAttachmentProductTags {
     }
 }
 
-export { API_REGIONS, index$6 as AdRepository, AmityAttachmentProductTags, AmityAutoSubscription, AmityChannelNotificationModeEnum, AmityCommunityType, AmityEventOrderOption, AmityEventOriginType, AmityEventResponseStatus, AmityEventSortOption, AmityEventStatus, AmityEventType, AmityLiveViewerCountMode, AmityModuleNotEntitledError, AmitySharableContentType, AnalyticsSourceTypeEnum, index$g as CategoryRepository, index$k as ChannelRepository, index$t as Client, index$f as CommentRepository, CommunityNotificationEventNameEnum, CommunityPostSettingMaps, CommunityPostSettings, index$h as CommunityRepository, ContentFeedType, ContentFlagReasonEnum, index as CuratedContentRepository, DefaultCommunityPostSetting, index$2 as EventRepository, FeedDataTypeEnum, index$e as FeedRepository, FeedSortByEnum, FeedSourceEnum, FeedTypeEnum, FileAccessTypeEnum, index$q as FileRepository, FileType, GET_WATCHER_URLS, index$4 as InvitationRepository, InvitationSortByEnum, InvitationStatusEnum, InvitationTargetTypeEnum, InvitationTypeEnum, JoinRequestStatusEnum, JoinResultStatusEnum, index$3 as LiveReactionRepository, index$8 as LiveStreamPlayer, MembershipAcceptanceTypeEnum, MessageContentType, index$o as MessageRepository, NotificationRolesFilterTypeEnum, NotificationSettingsLevelEnum, index$9 as PollRepository, PostContentType, index$c as PostRepository, PostStructureType, index$1 as ProductRepository, index$p as ReactionRepository, index$a as RoomPresenceRepository, index$d as RoomRepository, SearchUsersByEnum, index$7 as StoryRepository, index$b as StreamRepository, index$n as SubChannelRepository, SubscriptionLevels, UserNotificationModuleNameEnum, UserProfileFieldEnum, UserReportTypeEnum, index$r as UserRepository, UserTypeEnum, VERSION, VideoResolution, VideoSize, VideoTranscodingStatus, backupCache, createQuery, createReport, createUserToken, deleteReport, disableCache, dropFromCache, enableCache, exceedsUntilAtBoundary, filterByChannelMembership, filterByCommunityMembership, filterByFeedType, filterByPostDataTypes, filterByPropEquality, filterByPropInclusion, filterByPropIntersection, filterBySearchTerm, filterByStringComparePartially, filterByUntilAt, filterCommentsByBlockUsers, filterPostsByBlockUsers, getBlockUsersId, getChannelTopic, getCommentTopic, getCommunityStoriesTopic, getCommunityTopic, getLiveReactionTopic, getLiveStreamTopic, getMarkedMessageTopic, getMarkerUserFeedTopic, getMessageTopic, getMyFollowersTopic, getMyFollowingsTopic, getNetworkId, getNetworkTopic, getPostTopic, getRole, getRoomStreamerTopic, getRoomWatcherTopic, getSmartFeedChannelTopic, getSmartFeedMessageTopic, getSmartFeedSubChannelTopic, getStoryTopic, getSubChannelTopic, getUserTopic, isAfterBefore, isAfterBeforeRaw, isCachable, isFetcher, isFresh, isLocal, isMutator, isOffline, isPaged, isReportedByMe, isSkip, mergeInCache, index$5 as notificationTray, onChannelMarkerFetched, onFeedMarkerFetched, onFeedMarkerUpdated, onMessageMarked, onMessageMarkerFetched, onSubChannelMarkerFetched, onSubChannelMarkerUpdated, onUserMarkerFetched, onUserMarkerFetchedLegacy, pullFromCache, pushToCache, queryCache, queryOptions, queryRoles, resolveModuleAvailability, restoreCache, runQuery, sortByChannelSegment, sortByDisplayName, sortByFirstCreated, sortByFirstUpdated, sortByLastActivity, sortByLastCreated, sortByLastUpdated, sortByLocalSortingDate, sortByName, sortBySegmentNumber, subscribeTopic, toPage, toPageRaw, toToken, upsertInCache, validateUntilAt, wipeCache };
+export { API_REGIONS, index$6 as AdRepository, AmityAttachmentProductTags, AmityAutoSubscription, AmityChannelNotificationModeEnum, AmityCommunityType, AmityEventOrderOption, AmityEventOriginType, AmityEventResponseStatus, AmityEventSortOption, AmityEventStatus, AmityEventType, AmityLiveViewerCountMode, AmityModuleNotEntitledError, AmitySharableContentType, AnalyticsSourceTypeEnum, index$g as CategoryRepository, index$k as ChannelRepository, index$t as Client, index$f as CommentRepository, CommunityNotificationEventNameEnum, CommunityPostSettingMaps, CommunityPostSettings, index$h as CommunityRepository, ContentFeedType, ContentFlagReasonEnum, index as CuratedContentRepository, DefaultCommunityPostSetting, index$2 as EventRepository, FeedDataTypeEnum, index$e as FeedRepository, FeedSortByEnum, FeedSourceEnum, FeedTypeEnum, FileAccessTypeEnum, index$q as FileRepository, FileType, GET_WATCHER_URLS, index$4 as InvitationRepository, InvitationSortByEnum, InvitationStatusEnum, InvitationTargetTypeEnum, InvitationTypeEnum, JoinRequestStatusEnum, JoinResultStatusEnum, index$3 as LiveReactionRepository, index$8 as LiveStreamPlayer, MembershipAcceptanceTypeEnum, MessageContentType, index$o as MessageRepository, NotificationRolesFilterTypeEnum, NotificationSettingsLevelEnum, index$9 as PollRepository, PostContentType, index$c as PostRepository, PostStructureType, index$1 as ProductRepository, index$p as ReactionRepository, index$a as RoomPresenceRepository, index$d as RoomRepository, SearchUsersByEnum, index$7 as StoryRepository, index$b as StreamRepository, index$n as SubChannelRepository, SubscriptionLevels, UserNotificationModuleNameEnum, UserProfileFieldEnum, UserReportTypeEnum, UserReportTypeFilterEnum, index$r as UserRepository, UserTypeEnum, VERSION, VideoResolution, VideoSize, VideoTranscodingStatus, backupCache, createQuery, createReport, createUserToken, deleteReport, disableCache, dropFromCache, enableCache, exceedsUntilAtBoundary, filterByChannelMembership, filterByCommunityMembership, filterByFeedType, filterByPostDataTypes, filterByPropEquality, filterByPropInclusion, filterByPropIntersection, filterBySearchTerm, filterByStringComparePartially, filterByUntilAt, filterCommentsByBlockUsers, filterPostsByBlockUsers, getBlockUsersId, getChannelTopic, getCommentTopic, getCommunityStoriesTopic, getCommunityTopic, getLiveReactionTopic, getLiveStreamTopic, getMarkedMessageTopic, getMarkerUserFeedTopic, getMessageTopic, getMyFollowersTopic, getMyFollowingsTopic, getNetworkId, getNetworkTopic, getPostTopic, getRole, getRoomStreamerTopic, getRoomWatcherTopic, getSmartFeedChannelTopic, getSmartFeedMessageTopic, getSmartFeedSubChannelTopic, getStoryTopic, getSubChannelTopic, getUserTopic, isAfterBefore, isAfterBeforeRaw, isCachable, isFetcher, isFresh, isLocal, isMutator, isOffline, isPaged, isReportedByMe, isSkip, mergeInCache, index$5 as notificationTray, onChannelMarkerFetched, onFeedMarkerFetched, onFeedMarkerUpdated, onMessageMarked, onMessageMarkerFetched, onSubChannelMarkerFetched, onSubChannelMarkerUpdated, onUserMarkerFetched, onUserMarkerFetchedLegacy, pullFromCache, pushToCache, queryCache, queryOptions, queryRoles, resolveModuleAvailability, restoreCache, runQuery, sortByChannelSegment, sortByDisplayName, sortByFirstCreated, sortByFirstUpdated, sortByLastActivity, sortByLastCreated, sortByLastMessage, sortByLastUpdated, sortByLocalSortingDate, sortByName, sortBySegmentNumber, subscribeTopic, toPage, toPageRaw, toToken, upsertInCache, validateUntilAt, wipeCache };