@amityco/ts-sdk 0.0.1-beta.8 → 0.0.1-beta.9

package/dist/index.esm.js

@@ -1,15 +1,17 @@
+import isMatchWith from 'lodash.ismatchwith';
 import { encode, decode } from 'js-base64';
 import nativeIdGenerator from 'react-native-uuid';
 import debug from 'debug';
 import axios from 'axios';
 import HttpAgent, { HttpsAgent } from 'agentkeepalive';
 import io from 'socket.io-client';
+import mqtt from 'mqtt';
 import mitt from 'mitt';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 
 var _a;
 // used in createClient
-const VERSION$1 = (_a = 'v0.0.1-beta.8-esm') !== null && _a !== void 0 ? _a : '__dev__';
+const VERSION$1 = (_a = 'v0.0.1-beta.9-esm') !== null && _a !== void 0 ? _a : '__dev__';
 
 /**
  * Generic ASC error
@@ -276,24 +278,6 @@ const syncInCache = (original, replacement) => {
     pushToCache(name, replacement);
 };
 
-/**
- * Ingest a payload (v3) into the cache
- *
- * @param payload a "backend v3" payload object
- * @param order the order of the keys to process (in case of need)
- *
- * @category Cache
- */
-const ingestInCache = (payload = {}, order = Object.keys(payload)) => {
-    order
-        .forEach(key => {
-        const name = storeInterests[key];
-        if (!name)
-            return;
-        pushToCache(name, ...payload[key]);
-    });
-};
-
 /**
  * Apply partial mutation to objects in the cache
  *
@@ -325,6 +309,58 @@ const mergeInCache = (name, mutation) => {
     mutateCache(name, key, model => (Object.assign(Object.assign({}, model), mutation)));
 };
 
+/**
+ * converts an array looking collection to an object collection, grouped by localId
+ *
+ * @param array array of {@link Amity.Syncable}
+ * @returns array converted to object, grouped by localId
+ *
+ * @hidden
+ */
+const toRecord = (array) => (array.reduce((acc, item) => (Object.assign(Object.assign({}, acc), { [item.localId]: item })), {}));
+
+/** @hidden */
+const isMatch = (model1, model2) => {
+    const customizer = (oldValue, newValue, key) => {
+        if (key === 'syncedAt') {
+            return true;
+        }
+    };
+    return isMatchWith(model1, model2, customizer);
+};
+
+/**
+ * Ingest a payload (v3) into the cache
+ *
+ * @param payload a "backend v3" payload object
+ * @param order the order of the keys to process (in case of need)
+ *
+ * @category Cache
+ */
+const ingestInCache = (payload = {}, order = Object.keys(payload)) => {
+    order
+        .forEach(key => {
+        const name = storeInterests[key];
+        if (!name)
+            return;
+        payload[key].forEach(model => {
+            var _a;
+            const [cached] = (_a = pullFromCache(name, getResolver(name)(model))) !== null && _a !== void 0 ? _a : [];
+            if (cached) {
+                // > instead of >= - some updates like reactions do not change updatedAt
+                if (cached.updatedAt && cached.updatedAt > model.updatedAt) {
+                    return;
+                }
+                // personal fields like isJoined, myReactions are missed from real time event payload
+                mergeInCache(name, model);
+            }
+            else {
+                pushToCache(name, model);
+            }
+        });
+    });
+};
+
 /**
  * Creates a cache instance. The cache instance will handle stores
  * given to it as input, and will be used as the first source of cached data
@@ -755,6 +791,45 @@ const createLogger = (session) => {
     return print;
 };
 
+const API_ENDPOINT = {
+    EU: 'eu',
+    SG: 'sg',
+    US: 'us',
+};
+var UrlTemplate;
+(function (UrlTemplate) {
+    UrlTemplate["HTTP"] = "https://api.{region}.amity.co";
+    UrlTemplate["MQTT"] = "wss://sse.{region}.amity.co:443/mqtt";
+})(UrlTemplate || (UrlTemplate = {}));
+const getUrlFromTemplate = (template, region) => {
+    return template.replace('{region}', region);
+};
+
+/**
+ * Unwraps v3 server payload (for error handling and type extraction)
+ *
+ * @param response A typical "v3" response (related to backend's service strategy)
+ *
+ * @returns The data returned by the backend
+ * @throws An error related to backend's rejection
+ *
+ * @category Transport
+ * @hidden
+ */
+const unwrapPayload = (response) => {
+    if (response.status === 'success') {
+        return response.data;
+    }
+    else if (response.status === 'fail') {
+        throw new ASCUnknownError(response.code);
+    }
+    else if (response.status === 'error') {
+        throw new ASCApiError(response.message, response.code, "error" /* ERROR */);
+    }
+    // unjust, but helps force uncast "T | undefined" to allow deconstruction without warnings
+    return undefined;
+};
+
 /**
  * Axios param serializer (for querystring)
  * @hidden
@@ -783,7 +858,7 @@ const stringify = (params, prefix) => {
  * @category Transport
  * @hidden
  */
-const createHttpTransport = (endpoint = 'https://api.amity.co') => {
+const createHttpTransport = (endpoint) => {
     const options = {
         maxSockets: 100,
         maxFreeSockets: 10,
@@ -804,7 +879,8 @@ const createHttpTransport = (endpoint = 'https://api.amity.co') => {
             unwrapPayload(response.data);
     });
     return instance;
-};
+};
+
 /**
  * Creates a pre-configured socket.io instance
  *
@@ -814,42 +890,19 @@ const createHttpTransport = (endpoint = 'https://api.amity.co') => {
  * @category Transport
  * @hidden
  */
-const createWebsocketTransport = (endpoint = 'https://api.ekomedia.technology') => {
+const createWebsocketTransport = (endpoint) => {
     const socket = io(endpoint, {
         autoConnect: false,
         reconnectionDelay: 2000,
         transports: ['websocket'],
     });
+    // FIXME: disconnectClient removes this listener and client can get global ban event
     socket.on('disconnect', (reason) => {
         if (reason === 'io server disconnect')
             socket.connect();
     });
     return socket;
 };
-/**
- * Unwraps v3 server payload (for error handling and type extraction)
- *
- * @param response A typical "v3" response (related to backend's service strategy)
- *
- * @returns The data returned by the backend
- * @throws An error related to backend's rejection
- *
- * @category Transport
- * @hidden
- */
-const unwrapPayload = (response) => {
-    if (response.status === 'success') {
-        return response.data;
-    }
-    else if (response.status === 'fail') {
-        throw new ASCUnknownError(response.code);
-    }
-    else if (response.status === 'error') {
-        throw new ASCApiError(response.message, response.code, "error" /* ERROR */);
-    }
-    // unjust, but helps force uncast "T | undefined" to allow deconstruction without warnings
-    return undefined;
-};
 /**
  * Promisify a websocket event emission - resulting in a synchronous http-like XHR (ws legacy)
  *
@@ -879,14 +932,131 @@ const synchronousWSCall = async (client, event, data) => {
     return value;
 };
 
+const QOS_FAILURE_CODE = 128;
+const RETRY_BASE_TIMEOUT = 1000;
+const RETRY_COUNT_MAX = 10;
+var MqttError;
+(function (MqttError) {
+    MqttError[MqttError["IDENTIFIER_REJECTED"] = 2] = "IDENTIFIER_REJECTED";
+    MqttError[MqttError["BAD_USERNAME_OR_PASSWORD"] = 4] = "BAD_USERNAME_OR_PASSWORD";
+    MqttError[MqttError["NOT_AUTHORIZED"] = 5] = "NOT_AUTHORIZED";
+})(MqttError || (MqttError = {}));
+function getMqttOptions(params) {
+    return Object.assign({ clean: false, clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`, protocolId: 'MQTT', protocolVersion: 4, reconnectPeriod: 0, will: {
+            topic: 'WillMsg',
+            payload: 'Connection Closed abnormally..!',
+            qos: 0,
+            retain: false
+        } }, params);
+}
+/**
+ * Creates a pre-configured socket.io instance
+ *
+ * @param endpoint The mqtt server's URL
+ * @returns A pre-configured (non-connected) mqtt client instance
+ *
+ * @category Transport
+ * @hidden
+ */
+const createMqttTransport = (endpoint) => {
+    let mqttClient;
+    let retryCount = 0;
+    let allowReconnection = true;
+    async function connect(params) {
+        if (mqttClient) {
+            mqttClient.removeAllListeners();
+            mqttClient.end(true);
+        }
+        mqttClient = mqtt.connect(endpoint, getMqttOptions({ username: params.userId, password: params.accessToken }));
+        mqttClient.on('connect', () => {
+            retryCount = 0;
+            allowReconnection = true;
+        });
+        mqttClient.on('error', (error) => {
+            switch (error.code) {
+                case 2 /* IDENTIFIER_REJECTED */:
+                case 4 /* BAD_USERNAME_OR_PASSWORD */:
+                case 5 /* NOT_AUTHORIZED */:
+                    allowReconnection = false;
+            }
+        });
+        mqttClient.on('close', () => {
+            if (allowReconnection) {
+                reconnect();
+            }
+        });
+        return new Promise(resolve => mqttClient.once('connect', () => resolve()));
+    }
+    const reconnect = () => {
+        setTimeout(() => {
+            retryCount = retryCount + 1;
+            mqttClient.reconnect();
+        }, RETRY_BASE_TIMEOUT * Math.pow(2, retryCount > RETRY_COUNT_MAX ? RETRY_COUNT_MAX : retryCount));
+    };
+    return {
+        connect,
+        async disconnect() {
+            allowReconnection = false;
+            if (this.connected) {
+                return new Promise(resolve => mqttClient === null || mqttClient === void 0 ? void 0 : mqttClient.end(true, undefined, () => resolve()));
+            }
+        },
+        get connected() {
+            return !!(mqttClient === null || mqttClient === void 0 ? void 0 : mqttClient.connected);
+        },
+        on(event, handler) {
+            mqttClient === null || mqttClient === void 0 ? void 0 : mqttClient.on(event, handler);
+        },
+        once(event, handler) {
+            mqttClient === null || mqttClient === void 0 ? void 0 : mqttClient.once(event, handler);
+        },
+        off(event, handler) {
+            if (handler !== undefined) {
+                mqttClient === null || mqttClient === void 0 ? void 0 : mqttClient.off(event, handler);
+            }
+            else {
+                mqttClient === null || mqttClient === void 0 ? void 0 : mqttClient.removeAllListeners(event);
+            }
+        },
+        removeAllListeners() {
+            mqttClient === null || mqttClient === void 0 ? void 0 : mqttClient.removeAllListeners();
+        },
+        subscribe(topic, callback) {
+            const callbackWrapper = (error, granted) => {
+                if (error || granted[0].qos === QOS_FAILURE_CODE) {
+                    const ascError = error
+                        ? new ASCError(error.message, 800000 /* UNKNOWN_ERROR */, "error" /* ERROR */)
+                        // TODO throw the actual error, once BE can tell us the actual error code
+                        : new ASCUnknownError(800000 /* UNKNOWN_ERROR */, "error" /* ERROR */);
+                    console.error(`Failed to subscribe to topic ${topic}`, ascError);
+                    callback === null || callback === void 0 ? void 0 : callback(ascError);
+                }
+                else {
+                    console.log(`Subscribed to topic ${granted[0].topic}`);
+                    callback === null || callback === void 0 ? void 0 : callback();
+                }
+            };
+            if (mqttClient) {
+                mqttClient.subscribe(topic, { qos: 0 }, callbackWrapper);
+            }
+            else {
+                callbackWrapper(new Error('No connection to broker'), []);
+            }
+            return () => mqttClient === null || mqttClient === void 0 ? void 0 : mqttClient.unsubscribe(topic);
+        },
+        unsubscribe(topic) {
+            mqttClient === null || mqttClient === void 0 ? void 0 : mqttClient.unsubscribe(topic);
+        }
+    };
+};
+
 // need to sync up the list
-const EVENTS$1 = [
+const WS_EVENTS = [
     'disconnected',
     'error',
     'connect_error',
     'reconnect_error',
     'reconnect_failed',
-    'v3.user.didUpdate',
     'v3.channel.didUpdate',
     'v3.channel.didUpdate',
     'v3.channel.didJoin',
@@ -899,6 +1069,15 @@ const EVENTS$1 = [
     'v3.message.didUpdate',
     'v3.message.didDelete',
 ];
+const MQTT_EVENTS = [
+    'connect',
+    'message',
+    'disconnect',
+    'error',
+    'close',
+    'end',
+    'reconnect'
+];
 /** @hidden */
 const createEventEmitter = () => {
     return mitt();
@@ -914,10 +1093,20 @@ const createEventEmitter = () => {
  * @hidden
  */
 const proxyWebsocketEvents = (ws, emitter) => {
-    EVENTS$1.forEach(event => {
+    WS_EVENTS.forEach(event => {
         ws.on(event, (param) => emitter.emit(event, param));
     });
 };
+const proxyMqttEvents = (mqttClient, emitter) => {
+    MQTT_EVENTS.forEach(event => {
+        mqttClient.on(event, (...params) => emitter.emit(event, params.length === 1 ? params[0] : params));
+    });
+    // @ts-ignore
+    mqttClient.on('message', (topic, payload) => {
+        const message = JSON.parse(payload.toString());
+        emitter.emit(message.eventType, message.data);
+    });
+};
 /**
  * Standardize the subscription of SSE through web sockets
  *
@@ -969,14 +1158,15 @@ const fireEvent = (event, payload) => {
  *
  * @category Client API
  **/
-const createClient = (apiKey, apiEndpoint = 'https://api.amity.co', debugSession = 'amity') => {
+const createClient = (apiKey, apiEndpoint = API_ENDPOINT.SG, debugSession = 'amity') => {
     const log = createLogger(debugSession);
     log('client/api/createClient', {
         apiKey: apiKey.replace(/.{5}$/g, 'xxxxx'),
         apiEndpoint,
     });
-    const http = createHttpTransport(apiEndpoint);
-    const ws = createWebsocketTransport(apiEndpoint);
+    const http = createHttpTransport(getUrlFromTemplate(UrlTemplate.HTTP, apiEndpoint));
+    const ws = createWebsocketTransport(getUrlFromTemplate(UrlTemplate.HTTP, apiEndpoint));
+    const mqtt = createMqttTransport(getUrlFromTemplate(UrlTemplate.MQTT, apiEndpoint));
     const emitter = createEventEmitter();
     const client = {
         version: `${VERSION$1}`,
@@ -984,6 +1174,7 @@ const createClient = (apiKey, apiEndpoint = 'https://api.amity.co', debugSession
         log,
         http,
         ws,
+        mqtt,
         emitter,
         use: () => setActiveClient(client),
     };
@@ -996,6 +1187,38 @@ const createClient = (apiKey, apiEndpoint = 'https://api.amity.co', debugSession
     return client;
 };
 
+/**
+ * ```js
+ * import { disconnectClient } from '@amityco/ts-sdk'
+ * const success = await disconnectClient()
+ * ```
+ *
+ * Disconnects an {@link Amity.Client} instance from ASC servers
+ *
+ * @param client The {@link Amity.Client} instance to disconnect
+ * @returns a success boolean if disconnected
+ *
+ * @category Client API
+ * @async
+ */
+const disconnectClient = async () => {
+    const client = getActiveClient();
+    client.log('client/api/disconnectClient');
+    await new Promise(resolve => {
+        client.ws.once('disconnect', resolve);
+        client.ws.disconnect();
+        client.mqtt.disconnect();
+    });
+    client.emitter.all.clear();
+    // FIXME: it removes listener in ws.ts, it breaks global ban event
+    client.ws.removeAllListeners();
+    client.mqtt.removeAllListeners();
+    client.userId = undefined;
+    client.user = undefined;
+    client.accessToken = undefined;
+    return !client.ws.connected;
+};
+
 // TODO: find a way to uniquely identify the device
 // import { getStorage } from './storage'
 /** @hidden */
@@ -1052,6 +1275,83 @@ const getToken = async (params) => {
     return data;
 };
 
+const EVENTS = [
+    'disconnected',
+    'error',
+    'connect_error',
+    'reconnect_error',
+    'reconnect_failed',
+];
+/**
+ * ```js
+ * import { onConnectionError } from '@amityco/ts-sdk'
+ * const dispose = onClientBanned(() => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} have been banned from the platform
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+const onConnectionError = (callback) => {
+    const client = getActiveClient();
+    const subscribers = EVENTS.map(event => (createEventSubscriber(client, `client/onConnectionError(${event})`, event, (response) => {
+        const error = (response && 'code' in response)
+            ? new ASCError(response.message, response.code, "fatal" /* FATAL */)
+            : new ASCConnectionError(event);
+        callback(error);
+    })));
+    return () => {
+        subscribers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { onClientDisconnected } from '@amityco/ts-sdk'
+ * const dispose = onClientDisconnected(() => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} have been disconnected
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+const onClientDisconnected = (callback) => {
+    return onConnectionError(({ code }) => {
+        code === 800211 /* DISCONNECTED */ && callback();
+    });
+};
+
+/**
+ * ```js
+ * import { onClientBanned } from '@amityco/ts-sdk'
+ * const dispose = onClientBanned(() => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} have been banned from the platform
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+const onClientBanned = (callback) => {
+    return onConnectionError(({ code }) => {
+        code === 400312 /* GLOBAL_BAN */ && callback();
+    });
+};
+
 /**
  * ```js
  * import { connectClient } from '@amityco/ts-sdk/client/api'
@@ -1080,11 +1380,12 @@ const connectClient = async (params) => {
     (_b = params.deviceId) !== null && _b !== void 0 ? _b : (params.deviceId = getDeviceId());
     // @ts-ignore: in that particular case, typing can be
     // ignored since we enforce default values just before.
-    const { accessToken } = await getToken(params);
+    const { accessToken, users } = await getToken(params);
     // manually setup the token for http transport
     client.http.defaults.headers.common['Authorization'] = `Bearer ${accessToken}`;
     // manually setup the token for ws transport
     client.ws.io.opts.query = { token: accessToken };
+    // FIXME: events are duplicated if connectClient is called few times without disconnectClient
     // wire websocket events to our event emitter
     proxyWebsocketEvents(client.ws, client.emitter);
     // TODO: in phase 2, this should not be necessary. we should have WS
@@ -1093,41 +1394,20 @@ const connectClient = async (params) => {
         client.ws.once('connect', resolve);
         client.ws.open();
     });
+    const unsubscribe = onClientBanned(() => {
+        disconnectClient();
+        unsubscribe();
+    });
     client.userId = params.userId;
+    client.user = users[0];
+    client.accessToken = accessToken;
     return client.ws.connected;
 };
 
 /**
  * ```js
- * import { disconnectClient } from '@amityco/ts-sdk'
- * const success = await disconnectClient()
- * ```
- *
- * Disconnects an {@link Amity.Client} instance from ASC servers
- *
- * @param client The {@link Amity.Client} instance to disconnect
- * @returns a success boolean if disconnected
- *
- * @category Client API
- * @async
- */
-const disconnectClient = async () => {
-    const client = getActiveClient();
-    client.log('client/api/disconnectClient');
-    await new Promise(resolve => {
-        client.ws.once('disconnect', resolve);
-        client.ws.disconnect();
-    });
-    client.emitter.all.clear();
-    client.ws.removeAllListeners();
-    client.userId = undefined;
-    return !client.ws.connected;
-};
-
-/**
- * ```js
- * import { isConnected } from '@amityco/ts-sdk'
- * const connected = isConnected()
+ * import { isConnected } from '@amityco/ts-sdk'
+ * const connected = isConnected()
  * ```
  *
  * Checks if a {@link Amity.Client} instance is connected to ASC servers
@@ -1280,16 +1560,6 @@ const clearCache = (stores = ['user', 'file', 'channel', 'message', 'community',
     stores.forEach(store => { var _a, _b; return (_b = (_a = client.cache) === null || _a === void 0 ? void 0 : _a[store]) === null || _b === void 0 ? void 0 : _b.erase(); });
 };
 
-/**
- * converts an array looking collection to an object collection, grouped by localId
- *
- * @param array array of {@link Amity.Syncable}
- * @returns array converted to object, grouped by localId
- *
- * @hidden
- */
-const toRecord = (array) => (array.reduce((acc, item) => (Object.assign(Object.assign({}, acc), { [item.localId]: item })), {}));
-
 /**
  * Set the model's syncedAt property and localId
  *
@@ -1375,82 +1645,51 @@ const sortByLastCreated = ({ createdAt: a }, { createdAt: b }) => new Date(b).va
  */
 const sortByLastActivity = ({ lastActivity: a }, { lastActivity: b }) => new Date(b).valueOf() - new Date(a).valueOf();
 
-const EVENTS = [
-    'disconnected',
-    'error',
-    'connect_error',
-    'reconnect_error',
-    'reconnect_failed',
-];
-/**
- * ```js
- * import { onConnectionError } from '@amityco/ts-sdk'
- * const dispose = onClientBanned(() => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Client} have been banned from the platform
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Client Events
- */
-const onConnectionError = (callback) => {
-    const client = getActiveClient();
-    const subscribers = EVENTS.map(event => (createEventSubscriber(client, `client/onConnectionError(${event})`, event, (response) => {
-        const error = (response && 'code' in response)
-            ? new ASCError(response.message, response.code, "fatal" /* FATAL */)
-            : new ASCConnectionError(event);
-        callback(error);
-    })));
-    return () => {
-        subscribers.forEach(fn => fn());
-    };
-};
-
-/**
- * ```js
- * import { onClientDisconnected } from '@amityco/ts-sdk'
- * const dispose = onClientDisconnected(() => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Client} have been disconnected
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Client Events
- */
-const onClientDisconnected = (callback) => {
-    return onConnectionError(({ code }) => {
-        code === 800211 /* DISCONNECTED */ && callback();
-    });
-};
-
-/**
- * ```js
- * import { onClientBanned } from '@amityco/ts-sdk'
- * const dispose = onClientBanned(() => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Client} have been banned from the platform
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Client Events
- */
-const onClientBanned = (callback) => {
-    return onConnectionError(({ code }) => {
-        code === 400312 /* GLOBAL_BAN */ && callback();
-    });
-};
+var SubscriptionLevels;
+(function (SubscriptionLevels) {
+    SubscriptionLevels["COMMUNITY"] = "community";
+    SubscriptionLevels["POST"] = "post";
+    SubscriptionLevels["COMMENT"] = "comment";
+    SubscriptionLevels["POST_AND_COMMENT"] = "post_and_comment";
+    SubscriptionLevels["USER"] = "user";
+})(SubscriptionLevels || (SubscriptionLevels = {}));
+const getCommunityUserTopic = ({ path }, level) => {
+    switch (level) {
+        case 'post':
+            return `${path}/post/+`;
+        case 'comment':
+            return `${path}/post/+/comment/+`;
+        case 'post_and_comment':
+            return `${path}/post/#`;
+        default:
+            return path;
+    }
+};
+const getCommunityTopic = ({ path }, level = SubscriptionLevels.COMMUNITY) => getCommunityUserTopic({ path }, level);
+const getUserTopic = ({ path }, level = SubscriptionLevels.USER) => getCommunityUserTopic({ path }, level);
+const getPostTopic = ({ path }, level = SubscriptionLevels.POST) => {
+    switch (level) {
+        case 'comment':
+            return `${path}/comment/+`;
+        default:
+            return path;
+    }
+};
+const getCommentTopic = ({ path }) => {
+    return path;
+};
+let mqttAccessToken;
+let mqttUserId;
+function subscribeTopic(topic, callback) {
+    const { mqtt, emitter, accessToken, user } = getActiveClient();
+    if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
+        mqttAccessToken = accessToken;
+        mqttUserId = user._id;
+        mqtt.connect({ accessToken: accessToken, userId: user._id });
+        proxyMqttEvents(mqtt, emitter);
+    }
+    return mqtt.subscribe(topic, callback);
+}
 
 /**
  * ```js
@@ -1652,6 +1891,16 @@ const updateUser = async (userId, patch) => {
     return data.users.find(user => user.userId === userId);
 };
 
+const createUserEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.users[0]);
+    };
+    return createEventSubscriber(client, event, event, filter);
+};
+
 /**
  * ```js
  * import { onUserUpdated } from '@amityco/ts-sdk'
@@ -1660,22 +1909,65 @@ const updateUser = async (userId, patch) => {
  * })
  * ```
  *
- * Fired when any {@link Amity.User} have been updated
+ * 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) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.users[0]);
-    };
-    return createEventSubscriber(client, 'user/onUserUpdate', 'v3.user.didUpdate', filter);
-};
+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
@@ -1709,7 +2001,7 @@ const observeUser = (userId, callback) => {
         (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
     };
     const disposers = [];
-    disposers.push(onUserUpdated(data => router({ data }, 'onUpdate')));
+    disposers.push(onUserUpdated(data => router({ data }, 'onUpdate')), onUserFlagged(data => router({ data }, 'onFlagged')), onUserUnflagged(data => router({ data }, 'onUnflagged')), onUserFlagCleared(data => router({ data }, 'onFlagCleared')));
     runQuery(createQuery(getUser, userId), (result) => result.data && router(result, 'onFetch'));
     return () => {
         log(`observeUser(tmpid: ${timestamp}) > dispose`);
@@ -1973,10 +2265,10 @@ const dispatchReactable = (referenceType, model) => {
         fireEvent('v3.message.didUpdate', { messages: [model] });
     else if (referenceType === 'post')
         // @ts-ignore: refactor later
-        fireEvent('v3.post.didUpdate', { posts: [model] });
+        fireEvent('post.updated', { posts: [model] });
     else if (referenceType === 'comment')
         // @ts-ignore: refactor later
-        fireEvent('v3.comment.didUpdate', { comments: [model] });
+        fireEvent('comment.updated', { comments: [model] });
 };
 
 /**
@@ -2509,8 +2801,8 @@ const createPost = async (bundle) => {
     const { data } = await client.http.post('/api/v3/posts', bundle);
     decoratePayload(data);
     ingestInCache(data);
-    fireEvent('v3.community.didUpdate', { communities: data.communities });
-    fireEvent('v3.post.didCreate', data);
+    fireEvent('community.updated', { communities: data.communities });
+    fireEvent('post.created', data);
     const { posts } = data;
     return posts[0];
 };
@@ -2538,7 +2830,7 @@ const updatePost = async (postId, patch) => {
     const { data } = await client.http.put(`/api/v3/posts/${postId}`, patch);
     decoratePayload(data);
     ingestInCache(data);
-    fireEvent('v3.post.didUpdate', data);
+    fireEvent('post.updated', data);
     const { posts } = data;
     return posts.find(post => post.postId === postId);
 };
@@ -2708,7 +3000,7 @@ const createCommunity = async (bundle) => {
     const { data } = await client.http.post('/api/v3/communities/', bundle);
     decoratePayload(data);
     ingestInCache(data);
-    fireEvent('v3.community.didCreate', data);
+    fireEvent('community.created', data);
     const { communities } = data;
     return communities[0];
 };
@@ -2734,7 +3026,7 @@ const updateCommunity = async (communityId, patch) => {
     const { data } = await client.http.put(`/api/v3/communities/${communityId}`, patch);
     decoratePayload(data);
     ingestInCache(data);
-    fireEvent('v3.community.didUpdate', data);
+    fireEvent('community.updated', data);
     const { communities } = data;
     return communities.find(community => community.communityId === communityId);
 };
@@ -2759,7 +3051,7 @@ const deleteCommunity = async (communityId) => {
     // API-FIX: This endpoint has not been implemented yet.
     await client.http.delete(`/api/v3/communities/${communityId}`);
     const deleted = await getCommunity(communityId);
-    fireEvent('v3.community.didDelete', { communities: [deleted] });
+    fireEvent('community.deleted', { communities: [deleted] });
     return deleted;
 };
 
@@ -2783,7 +3075,7 @@ const joinCommunity = async (communityId) => {
     const { data } = await client.http.post(`/api/v3/communities/${communityId}/join`);
     decoratePayload(data);
     ingestInCache(data);
-    fireEvent('v3.community.didJoin', {
+    fireEvent('community.joined', {
         communities: data.communities
     });
     const { communityUsers } = data;
@@ -2811,7 +3103,7 @@ const leaveCommunity = async (communityId) => {
     const { data } = await client.http.delete(`/api/v3/communities/${communityId}/leave`);
     decoratePayload(data);
     ingestInCache(data);
-    fireEvent('v3.community.didJoin', {
+    fireEvent('community.left', {
         communities: data.communities,
     });
     const { communityUsers } = data;
@@ -2890,7 +3182,7 @@ const addCommunityMembers = async (communityId, userIds) => {
     const { data } = await client.http.post(`/api/v3/communities/${communityId}/users`, { communityId, userIds });
     decoratePayload(data);
     ingestInCache(data);
-    fireEvent('v3.community.didAddUsers', {
+    fireEvent('community.userAdded', {
         communities: data.communities,
     });
     const { communityUsers } = data;
@@ -2919,7 +3211,7 @@ const removeCommunityMembers = async (communityId, userIds) => {
     const { data } = await client.http.delete(`/api/v3/communities/${communityId}/users`, { data: { communityId, userIds } });
     decoratePayload(data);
     ingestInCache(data);
-    fireEvent('v3.community.didRemoveUsers', {
+    fireEvent('community.userRemoved', {
         communities: data.communities,
     });
     const { communityUsers } = data;
@@ -3010,11 +3302,11 @@ const deletePost = async (postId, permanent = false) => {
     // later when realtime events covers that for us.
     if (post.targetType === 'community') {
         const community = await getCommunity(post.targetId);
-        fireEvent('v3.community.didUpdate', { communities: [community] });
+        fireEvent('community.updated', { communities: [community] });
     }
     // to support hard deletion
     const deleted = Object.assign(Object.assign({}, post), { isDeleted: true });
-    fireEvent('v3.post.didDelete', { posts: [deleted] });
+    fireEvent('post.deleted', { posts: [deleted] });
     if (permanent) {
         setTimeout(() => {
             dropFromCache('post', { postId });
@@ -3262,8 +3554,8 @@ const createComment = async (bundle) => {
     decoratePayload(data);
     ingestInCache(data);
     const post = await getPost(bundle.referenceId);
-    fireEvent('v3.post.didUpdate', { posts: [post] });
-    fireEvent('v3.comment.didCreate', data);
+    fireEvent('post.updated', { posts: [post] });
+    fireEvent('comment.created', data);
     const { comments } = data;
     return comments[0];
 };
@@ -3291,7 +3583,7 @@ const updateComment = async (commentId, patch) => {
     const { data } = await client.http.put(`/api/v3/comments/${commentId}`, patch);
     decoratePayload(data);
     ingestInCache(data);
-    fireEvent('v3.comment.didUpdate', data);
+    fireEvent('comment.updated', data);
     const { comments } = data;
     return comments.find(comment => comment.commentId === commentId);
 };
@@ -3324,8 +3616,8 @@ const deleteComment = async (commentId, permanent = false) => {
     // to support hard deletion
     const deleted = Object.assign(Object.assign({}, comment), { isDeleted: true });
     const post = await getPost(comment.referenceId);
-    fireEvent('v3.post.didUpdate', { posts: [post] });
-    fireEvent('v3.comment.didDelete', { comments: [deleted] });
+    fireEvent('post.updated', { posts: [post] });
+    fireEvent('comment.deleted', { comments: [deleted] });
     if (permanent) {
         setTimeout(() => {
             dropFromCache('comment', { commentId });
@@ -3348,6 +3640,42 @@ const fetchReference = async (referenceType, referenceId) => {
     throw new Error(`Incorrect referenceType: ${referenceType}`);
 };
 
+/** @hidden */
+const preparePayloadForCache = (event, payload) => {
+    var _a, _b;
+    const client = getActiveClient();
+    if (client.userId !== payload.reactor.userId) {
+        return;
+    }
+    let model;
+    let cached;
+    if (event === 'post.addReaction' || event === 'post.removeReaction') {
+        const post = payload.posts[0];
+        cached = ((_a = pullFromCache('post', post.postId)) !== null && _a !== void 0 ? _a : [])[0];
+        model = post;
+    }
+    else {
+        const comment = payload.comments[0];
+        cached = ((_b = pullFromCache('comment', comment.commentId)) !== null && _b !== void 0 ? _b : [])[0];
+        model = comment;
+    }
+    if (!cached || !cached.myReactions) {
+        return;
+    }
+    if (event === 'post.addReaction' || event === 'comment.addReaction') {
+        if (cached.myReactions.includes(payload.reactor.reactionName)) {
+            return;
+        }
+        Object.assign(model, { myReactions: [...cached.myReactions, payload.reactor.reactionName] });
+    }
+    else {
+        if (!cached.myReactions.includes(payload.reactor.reactionName)) {
+            return;
+        }
+        Object.assign(model, { myReactions: cached.myReactions.filter(x => x !== payload.reactor.reactionName) });
+    }
+};
+
 /**
  * ```js
  * import { addReaction } from '@amityco/ts-sdk'
@@ -3460,75 +3788,468 @@ removeReaction.optimistically = (referenceType, referenceId, reactionName) => {
     return (_b = !((_a = model === null || model === void 0 ? void 0 : model.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName))) !== null && _b !== void 0 ? _b : false;
 };
 
+const createPostEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        var _a, _b;
+        const [cached] = (_a = pullFromCache('post', payload.posts[0].postId)) !== null && _a !== void 0 ? _a : [];
+        const { communities } = payload, others = __rest(payload, ["communities"]);
+        decoratePayload(others);
+        ingestInCache(others);
+        if (communities === null || communities === void 0 ? void 0 : communities[0]) {
+            fireEvent('community.updated', { communities });
+        }
+        const [post] = (_b = pullFromCache('post', others.posts[0].postId)) !== null && _b !== void 0 ? _b : [];
+        if (cached && isMatch(cached, post)) {
+            return;
+        }
+        callback(post);
+    };
+    return createEventSubscriber(client, event, event, filter);
+};
+
 /**
  * ```js
- * import { onReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onReactionRemoved(message => {
+ * import { onPostCreated } from '@amityco/ts-sdk'
+ * const dispose = onPostCreated(post => {
  *   // ...
  * })
  * ```
  *
- * Fired when an {@link Amity.Reaction} has been removed
+ * Fired when {@link Amity.Post} 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 onReactionRemoved = (referenceType, referenceId, callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        // TODO: lol
-        decoratePayload(payload);
-        ingestInCache(payload);
-    };
-    return createEventSubscriber(client, 'reaction/onReactionRemoved', 'v3.message.didUpdate', filter);
-};
-
-var REFERENCE_TYPES = {
-    post: {
-        domainName: 'posts',
-        eventName: 'v3/post.isflagbyme',
-        primaryKey: 'postId',
-    },
-    comment: {
-        domainName: 'comments',
-        eventName: 'v3/comment.isflagbyme',
-        primaryKey: 'commentId',
-    },
-    message: {
-        domainName: 'messages',
-        eventName: 'v3/message.isFlaggedByMe',
-        primaryKey: 'messageId',
-    },
-    user: {
-        domainName: 'users',
-        eventName: 'user.isFlagByMe',
-        primaryKey: 'userId',
-    },
-};
+ * @category Post Events
+ */
+const onPostCreated = (callback) => createPostEventSubscriber('post.created', callback);
 
 /**
  * ```js
- * import { createReport } from '@amityco/ts-sdk'
- * const flagged = await createReport('post', postId)
+ * import { onPostUpdated } from '@amityco/ts-sdk'
+ * const dispose = onPostUpdated(post => {
+ *   // ...
+ * })
  * ```
  *
- * @param referenceType The type of thing to add a report to, such as a post or a comment.
- * @param referenceId The ID of the thing to add a new report to.
- * @returns the created report result
+ * Fired when a {@link Amity.Post} has been updated
  *
- * @category Report API
- * @async
- **/
-const createReport = async (referenceType, referenceId) => {
-    const client = getActiveClient();
-    client.log('report/createReport', { referenceType, referenceId });
-    const { domainName } = REFERENCE_TYPES[referenceType];
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onPostUpdated = (callback) => createPostEventSubscriber('post.updated', callback);
+
+/**
+ * ```js
+ * import { onPostDeleted } from '@amityco/ts-sdk'
+ * const dispose = onPostDeleted(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onPostDeleted = (callback) => createPostEventSubscriber('post.deleted', callback);
+
+/**
+ * ```js
+ * import { onPostApproved } from '@amityco/ts-sdk'
+ * const dispose = onPostApproved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onPostApproved = (callback) => createPostEventSubscriber('post.approved', callback);
+
+/**
+ * ```js
+ * import { onPostDeclined } from '@amityco/ts-sdk'
+ * const dispose = onPostDeclined(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onPostDeclined = (callback) => createPostEventSubscriber('post.declined', callback);
+
+/**
+ * ```js
+ * import { onPostFlagged } from '@amityco/ts-sdk'
+ * const dispose = onPostFlagged(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onPostFlagged = (callback) => createPostEventSubscriber('post.flagged', callback);
+
+/**
+ * ```js
+ * import { onPostUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onPostUnflagged(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Post}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onPostUnflagged = (callback) => createPostEventSubscriber('post.unflagged', callback);
+
+/**
+ * ```js
+ * import { onPostReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionAdded(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} 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 onPostReactionAdded = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        var _a, _b;
+        const [cached] = (_a = pullFromCache('post', payload.posts[0].postId)) !== null && _a !== void 0 ? _a : [];
+        const postPayload = __rest(payload, ["reactor"]);
+        decoratePayload(postPayload);
+        preparePayloadForCache('post.addReaction', payload);
+        ingestInCache(postPayload);
+        const [post] = (_b = pullFromCache('post', payload.posts[0].postId)) !== null && _b !== void 0 ? _b : [];
+        if (cached && isMatch(cached, post)) {
+            return;
+        }
+        callback(post);
+    };
+    return createEventSubscriber(client, 'post.addReaction', 'post.addReaction', filter);
+};
+
+/**
+ * ```js
+ * import { onPostReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionRemoved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Post}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onPostReactionRemoved = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        var _a, _b;
+        const [cached] = (_a = pullFromCache('post', payload.posts[0].postId)) !== null && _a !== void 0 ? _a : [];
+        const postPayload = __rest(payload, ["reactor"]);
+        decoratePayload(postPayload);
+        preparePayloadForCache('post.removeReaction', payload);
+        ingestInCache(postPayload);
+        const [post] = (_b = pullFromCache('post', payload.posts[0].postId)) !== null && _b !== void 0 ? _b : [];
+        if (cached && isMatch(cached, post)) {
+            return;
+        }
+        callback(post);
+    };
+    return createEventSubscriber(client, 'post.removeReaction', 'post.removeReaction', filter);
+};
+
+const createCommentEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        var _a, _b;
+        const [cached] = (_a = pullFromCache('comment', payload.comments[0].commentId)) !== null && _a !== void 0 ? _a : [];
+        decoratePayload(payload);
+        ingestInCache(payload);
+        const [comment] = (_b = pullFromCache('comment', payload.comments[0].commentId)) !== null && _b !== void 0 ? _b : [];
+        if (cached && isMatch(cached, comment)) {
+            return;
+        }
+        callback(comment);
+    };
+    return createEventSubscriber(client, event, event, filter);
+};
+
+/**
+ * ```js
+ * import { onCommentCreated } from '@amityco/ts-sdk'
+ * const dispose = onCommentCreated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when {@link Amity.Comment} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentCreated = (callback) => createCommentEventSubscriber('comment.created', callback);
+
+/**
+ * ```js
+ * import { onCommentUpdated } from '@amityco/ts-sdk'
+ * const dispose = onCommentUpdated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentUpdated = (callback) => createCommentEventSubscriber('comment.updated', callback);
+
+/**
+ * ```js
+ * import { onCommentDeleted } from '@amityco/ts-sdk'
+ * const dispose = onCommentDeleted(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentDeleted = (callback) => createCommentEventSubscriber('comment.deleted', callback);
+
+/**
+ * ```js
+ * import { onCommentFlagged } from '@amityco/ts-sdk'
+ * const dispose = onCommentFlagged(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentFlagged = (callback) => createCommentEventSubscriber('comment.flagged', callback);
+
+/**
+ * ```js
+ * import { onCommentUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onCommentUnflagged(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Comment}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentUnflagged = (callback) => createCommentEventSubscriber('comment.unflagged', callback);
+
+/**
+ * ```js
+ * import { onCommentReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onCommentReactionAdded(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentReactionAdded = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        var _a, _b;
+        const [cached] = (_a = pullFromCache('comment', payload.comments[0].commentId)) !== null && _a !== void 0 ? _a : [];
+        const commentPayload = __rest(payload, ["reactor"]);
+        decoratePayload(commentPayload);
+        preparePayloadForCache('comment.addReaction', payload);
+        ingestInCache(commentPayload);
+        const [comment] = (_b = pullFromCache('comment', payload.comments[0].commentId)) !== null && _b !== void 0 ? _b : [];
+        if (cached && isMatch(cached, comment)) {
+            return;
+        }
+        callback(comment);
+    };
+    return createEventSubscriber(client, 'comment.addReaction', 'comment.addReaction', filter);
+};
+
+/**
+ * ```js
+ * import { onCommentReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onCommentReactionRemoved(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Comment}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentReactionRemoved = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        var _a, _b;
+        const [cached] = (_a = pullFromCache('comment', payload.comments[0].commentId)) !== null && _a !== void 0 ? _a : [];
+        const commentPayload = __rest(payload, ["reactor"]);
+        decoratePayload(commentPayload);
+        preparePayloadForCache('comment.removeReaction', payload);
+        ingestInCache(commentPayload);
+        const [comment] = (_b = pullFromCache('comment', payload.comments[0].commentId)) !== null && _b !== void 0 ? _b : [];
+        if (cached && isMatch(cached, comment)) {
+            return;
+        }
+        callback(comment);
+    };
+    return createEventSubscriber(client, 'comment.removeReaction', 'comment.removeReaction', filter);
+};
+
+/**
+ * ```js
+ * import { onReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onReactionRemoved('post', postId, post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reaction} has been removed
+ *
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ **/
+const onReactionRemoved = (referenceType, referenceId, callback) => {
+    const callbackWrapper = (model) => {
+        if (getResolver(referenceType)(model) === referenceId) {
+            callback(model);
+        }
+    };
+    if (referenceType === 'message') {
+        const client = getActiveClient();
+        const filter = (payload) => {
+            var _a, _b;
+            const reactionsCountInCache = (_b = ((_a = pullFromCache('message', payload.messages[0].messageId)) !== null && _a !== void 0 ? _a : [])[0]) === null || _b === void 0 ? void 0 : _b.reactionsCount;
+            const isReactionEvent = reactionsCountInCache !== payload.messages[0].reactionsCount;
+            decoratePayload(payload);
+            ingestInCache(payload);
+            if (isReactionEvent) {
+                callbackWrapper(payload.messages[0]);
+            }
+        };
+        return createEventSubscriber(client, 'reaction/onReactionRemoved', 'v3.message.didUpdate', filter);
+    }
+    if (referenceType === 'post') {
+        return onPostReactionRemoved(callbackWrapper);
+    }
+    return onCommentReactionRemoved(callbackWrapper);
+};
+
+var REFERENCE_TYPES = {
+    post: {
+        domainName: 'posts',
+        eventName: 'v3/post.isflagbyme',
+        primaryKey: 'postId',
+    },
+    comment: {
+        domainName: 'comments',
+        eventName: 'v3/comment.isflagbyme',
+        primaryKey: 'commentId',
+    },
+    message: {
+        domainName: 'messages',
+        eventName: 'v3/message.isFlaggedByMe',
+        primaryKey: 'messageId',
+    },
+    user: {
+        domainName: 'users',
+        eventName: 'user.isFlagByMe',
+        primaryKey: 'userId',
+    },
+};
+
+/**
+ * ```js
+ * import { createReport } from '@amityco/ts-sdk'
+ * const flagged = await createReport('post', postId)
+ * ```
+ *
+ * @param referenceType The type of thing to add a report to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new report to.
+ * @returns the created report result
+ *
+ * @category Report API
+ * @async
+ **/
+const createReport = async (referenceType, referenceId) => {
+    const client = getActiveClient();
+    client.log('report/createReport', { referenceType, referenceId });
+    const { domainName } = REFERENCE_TYPES[referenceType];
     const { data } = await client.http.post(`/api/v3/${domainName}/${referenceId}/flag`);
+    const event = referenceType === 'message'
+        ? 'v3.message.didUpdate'
+        : `${referenceType}.updated`;
     decoratePayload(data);
     ingestInCache(data);
-    fireEvent(`v3.${referenceType}.didUpdate`, data);
+    fireEvent(event, data);
     return !!data;
 };
 
@@ -3550,9 +4271,12 @@ const deleteReport = async (referenceType, referenceId) => {
     client.log('report/deleteReport', { referenceType, referenceId });
     const { domainName } = REFERENCE_TYPES[referenceType];
     const { data } = await client.http.delete(`/api/v3/${domainName}/${referenceId}/unflag`);
+    const event = referenceType === 'message'
+        ? 'v3.message.didUpdate'
+        : `${referenceType}.updated`;
     decoratePayload(data);
     ingestInCache(data);
-    fireEvent(`v3.${referenceType}.didUpdate`, data);
+    fireEvent(event, data);
     return !!data;
 };
 
@@ -4322,166 +5046,253 @@ const observeMessage = (messageId, callback, policy = 'cache_then_server') => {
 
 /**
  * ```js
- * import { observeMessages } from '@amityco/ts-sdk'
+ * import { observeMessages } from '@amityco/ts-sdk'
+ *
+ * let messages = []
+ * const unsub = observeMessages(channelId, message => merge(messages, message))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.Channel} object
+ *
+ * @param client the client to observe the message with
+ * @param channelId the ID of the channel where to observe the messages
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ *
+ * @category Message Observer
+ */
+const observeMessages = (channelId, callback) => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    log(`observeMessages(tmpid: ${timestamp}) > listen`);
+    const disposers = [];
+    const router = (message, action) => {
+        var _a, _b;
+        if (message.channelId !== channelId)
+            return;
+        if (callback instanceof Function)
+            return callback(message);
+        (_a = callback.onEvent) === null || _a === void 0 ? void 0 : _a.call(callback, action, message);
+        (_b = callback[action]) === null || _b === void 0 ? void 0 : _b.call(callback, message);
+    };
+    disposers.push(onMessageCreated(message => router(message, 'onCreate')), onMessageUpdated(message => router(message, 'onUpdate')), onMessageDeleted(message => router(message, 'onDelete')));
+    return () => {
+        log(`observeMessages(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+const createCommunityEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        var _a, _b;
+        const [cached] = (_a = pullFromCache('community', payload.communities[0].communityId)) !== null && _a !== void 0 ? _a : [];
+        decoratePayload(payload);
+        ingestInCache(payload);
+        const [community] = (_b = pullFromCache('community', payload.communities[0].communityId)) !== null && _b !== void 0 ? _b : [];
+        if (cached && isMatch(cached, community)) {
+            return;
+        }
+        callback(community);
+    };
+    return createEventSubscriber(client, event, event, filter);
+};
+function hasPermission(member, payload, permission) {
+    if (member.permissions.some(x => x === permission)) {
+        return true;
+    }
+    return payload.users
+        .find(user => user.userId === member.userId)
+        .permissions.some(x => x === permission);
+}
+function getEventRelatedMember(event, payload) {
+    if (event === 'community.joined' || event === 'community.left') {
+        return payload.communityUsers[0];
+    }
+    // NOTE: backend returns the one who took the action and the one on whom
+    // the action was taken. We need the 2nd one
+    if (event === 'community.userRemoved') {
+        return payload.communityUsers.filter(x => x.communityMembership === 'none')[0];
+    }
+    if (event === 'community.userBanned') {
+        return payload.communityUsers.filter(x => x.communityMembership === 'banned')[0];
+    }
+    // NOTE: it might be that in certain edge cases permission check won't be enough
+    if (event === 'community.userUnbanned') {
+        return payload.communityUsers.filter(x => !hasPermission(x, payload, 'BAN_COMMUNITY_USER'))[0];
+    }
+    return payload.communityUsers.filter(x => !hasPermission(x, payload, 'ADD_COMMUNITY_USER'))[0];
+}
+const createCommunityMemberEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        var _a, _b, _c, _d;
+        const [cachedCommunity] = (_a = pullFromCache('community', payload.communities[0].communityId)) !== null && _a !== void 0 ? _a : [];
+        const [cachedMember] = (_b = pullFromCache('communityUsers', getResolver('communityUsers')(getEventRelatedMember(event, payload)))) !== null && _b !== void 0 ? _b : [];
+        decoratePayload(payload);
+        ingestInCache(payload);
+        const [community] = (_c = pullFromCache('community', payload.communities[0].communityId)) !== null && _c !== void 0 ? _c : [];
+        const [member] = (_d = pullFromCache('communityUsers', getResolver('communityUsers')(getEventRelatedMember(event, payload)))) !== null && _d !== void 0 ? _d : [];
+        if (cachedCommunity && isMatch(cachedCommunity, community) && cachedMember && isMatch(cachedMember, member)) {
+            return;
+        }
+        callback(community, member);
+    };
+    return createEventSubscriber(client, event, event, filter);
+};
+
+/**
+ * ```js
+ * import { onCommunityCreated } from '@amityco/ts-sdk'
+ * const dispose = onCommunityCreated(community => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when {@link Amity.Community} have been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+const onCommunityCreated = (callback) => createCommunityEventSubscriber('community.created', callback);
+
+/**
+ * ```js
+ * import { onCommunityUpdated } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUpdated(community => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Community} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+const onCommunityUpdated = (callback) => createCommunityEventSubscriber('community.updated', callback);
+
+/**
+ * ```js
+ * import { onCommunityDeleted } from '@amityco/ts-sdk'
+ * const dispose = onCommunityDeleted(community => {
+ *   // ...
+ * })
+ * ```
  *
- * let messages = []
- * const unsub = observeMessages(channelId, message => merge(messages, message))
+ * Fired when a {@link Amity.Community} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+const onCommunityDeleted = (callback) => createCommunityEventSubscriber('community.deleted', callback);
+
+/**
+ * ```js
+ * import { onCommunityJoined } from '@amityco/ts-sdk'
+ * const dispose = onCommunityJoined((community, member) => {
+ *   // ...
+ * })
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.Channel} object
+ * Fired when a {@link Amity.Community} has been joined
  *
- * @param client the client to observe the message with
- * @param channelId the ID of the channel where to observe the messages
- * @param callback the function to call when new data are available
- * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Message Observer
+ * @category Community Events
  */
-const observeMessages = (channelId, callback) => {
-    const { log } = getActiveClient();
-    const timestamp = Date.now();
-    log(`observeMessages(tmpid: ${timestamp}) > listen`);
-    const disposers = [];
-    const router = (message, action) => {
-        var _a, _b;
-        if (message.channelId !== channelId)
-            return;
-        if (callback instanceof Function)
-            return callback(message);
-        (_a = callback.onEvent) === null || _a === void 0 ? void 0 : _a.call(callback, action, message);
-        (_b = callback[action]) === null || _b === void 0 ? void 0 : _b.call(callback, message);
-    };
-    disposers.push(onMessageCreated(message => router(message, 'onCreate')), onMessageUpdated(message => router(message, 'onUpdate')), onMessageDeleted(message => router(message, 'onDelete')));
-    return () => {
-        log(`observeMessages(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
-};
+const onCommunityJoined = (callback) => createCommunityMemberEventSubscriber('community.joined', callback);
 
 /**
  * ```js
- * import { onCommunityCreated } from '@amityco/ts-sdk'
- * const dispose = onCommunityCreated(channel => {
+ * import { onCommunityLeft } from '@amityco/ts-sdk'
+ * const dispose = onCommunityLeft((community, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} have been created
+ * Fired when a {@link Amity.Community} has been left
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Community Events
  */
-const onCommunityCreated = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.communities[0]);
-    };
-    return createEventSubscriber(client, 'onCommunityCreated', 'v3.community.didCreate', filter);
-};
+const onCommunityLeft = (callback) => createCommunityMemberEventSubscriber('community.left', callback);
 
 /**
  * ```js
- * import { onCommunityUpdated } from '@amityco/ts-sdk'
- * const dispose = onCommunityUpdated(channel => {
+ * import { onCommunityUserAdded } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserAdded((community, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} have been updated
+ * Fired when a user has been added to a {@link Amity.Community}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Community Events
  */
-const onCommunityUpdated = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.communities[0]);
-    };
-    return createEventSubscriber(client, 'onCommunityUpdated', 'v3.community.didUpdate', filter);
-};
+const onCommunityUserAdded = (callback) => createCommunityMemberEventSubscriber('community.userAdded', callback);
 
 /**
  * ```js
- * import { onCommunityDeleted } from '@amityco/ts-sdk'
- * const dispose = onCommunityDeleted(channel => {
+ * import { onCommunityUserRemoved } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserRemoved((community, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} have been deleted
+ * Fired when a user has been removed from a {@link Amity.Community}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Community Events
  */
-const onCommunityDeleted = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.communities[0]);
-    };
-    return createEventSubscriber(client, 'onCommunityDeleted', 'v3.community.didDelete', filter);
-};
+const onCommunityUserRemoved = (callback) => createCommunityMemberEventSubscriber('community.userRemoved', callback);
 
 /**
  * ```js
- * import { onCommunityJoined } from '@amityco/ts-sdk'
- * const dispose = onCommunityJoined(channel => {
+ * import { onCommunityUserBanned } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserBanned((community, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} was joined
+ * Fired when a user has been banned in a {@link Amity.Community}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Community Events
  */
-const onCommunityJoined = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.communities[0]);
-    };
-    return createEventSubscriber(client, 'onCommunityJoined', 'v3.community.didJoin', filter);
-};
+const onCommunityUserBanned = (callback) => createCommunityMemberEventSubscriber('community.userBanned', callback);
 
 /**
  * ```js
- * import { onCommunityLeft } from '@amityco/ts-sdk'
- * const dispose = onCommunityLeft(channel => {
+ * import { onCommunityUserUnbanned } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserUnbanned((community, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} was left
+ * Fired when a user has been unbanned in a {@link Amity.Community}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Community Events
  */
-const onCommunityLeft = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.communities[0]);
-    };
-    return createEventSubscriber(client, 'onCommunityLeft', 'v3.community.didLeave', filter);
-};
+const onCommunityUserUnbanned = (callback) => createCommunityMemberEventSubscriber('community.userUnbanned', callback);
 
 /**
  * ```js
@@ -4505,19 +5316,22 @@ const observeCommunity = (communityId, callback) => {
     log(`observeCommunity(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.communityId) !== communityId)
-            return;
+        var _a, _b;
         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);
+            (_a = callback.onEvent) === null || _a === void 0 ? void 0 : _a.call(callback, action, result);
+        (_b = callback[action]) === null || _b === void 0 ? void 0 : _b.call(callback, result);
+    };
+    const realtimeRouter = (result, action) => {
+        var _a;
+        if (((_a = result.data) === null || _a === void 0 ? void 0 : _a.communityId) !== communityId)
+            return;
+        router(result, action);
     };
     const disposers = [];
-    disposers.push(onCommunityUpdated(data => router({ data }, 'onUpdate')), onCommunityDeleted(data => router({ data }, 'onDelete')), onCommunityJoined(data => router({ data }, 'onJoin')), onCommunityLeft(data => router({ data }, 'onLeft')));
-    runQuery(createQuery(getCommunity, communityId), result => result.data && router(result, 'onFetch'));
+    disposers.push(onCommunityUpdated(data => realtimeRouter({ data }, 'onUpdate')), onCommunityDeleted(data => realtimeRouter({ data }, 'onDelete')), onCommunityJoined(data => realtimeRouter({ data }, 'onJoin')), onCommunityLeft(data => realtimeRouter({ data }, 'onLeft')), onCommunityUserAdded(data => realtimeRouter({ data }, 'onUserAdded')), onCommunityUserRemoved(data => realtimeRouter({ data }, 'onUserRemoved')), onCommunityUserBanned(data => realtimeRouter({ data }, 'onUserBanned')), onCommunityUserUnbanned(data => realtimeRouter({ data }, 'onUserUnbanned')));
+    runQuery(createQuery(getCommunity, communityId), result => router(result, 'onFetch'));
     return () => {
         log(`observeCommunity(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -4554,81 +5368,6 @@ const queryGlobalFeed = async (query) => {
     return { data: toRecord(posts), nextPage, prevPage };
 };
 
-/**
- * ```js
- * import { onPostCreated } from '@amityco/ts-sdk'
- * const dispose = onPostCreated(post => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.Post} has been created
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Post Events
- */
-const onPostCreated = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.posts[0]);
-    };
-    return createEventSubscriber(client, 'message/onPostCreated', 'v3.post.didCreate', filter);
-};
-
-/**
- * ```js
- * import { onPostUpdated } from '@amityco/ts-sdk'
- * const dispose = onPostUpdated(post => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.Post} has been updated
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Post Events
- */
-const onPostUpdated = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.posts[0]);
-    };
-    return createEventSubscriber(client, 'message/onPostUpdated', 'v3.post.didUpdate', filter);
-};
-
-/**
- * ```js
- * import { onPostDeleted } from '@amityco/ts-sdk'
- * const dispose = onPostDeleted(post => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.Post} has been deleted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Post Events
- */
-const onPostDeleted = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.posts[0]);
-    };
-    return createEventSubscriber(client, 'message/onPostDeleted', 'v3.post.didDelete', filter);
-};
-
 /**
  * ```js
  * import { observePosts } from '@amityco/ts-sdk'
@@ -4664,7 +5403,7 @@ const observePosts = (params, callback) => {
         (_a = callback.onEvent) === null || _a === void 0 ? void 0 : _a.call(callback, action, post);
         (_b = callback[action]) === null || _b === void 0 ? void 0 : _b.call(callback, post);
     };
-    disposers.push(onPostCreated(post => router(post, 'onCreate')), onPostUpdated(post => router(post, 'onUpdate')), onPostDeleted(post => router(post, 'onDelete')));
+    disposers.push(onPostCreated(post => router(post, 'onCreate')), onPostUpdated(post => router(post, 'onUpdate')), onPostDeleted(post => router(post, 'onDelete')), onPostApproved(post => router(post, 'onApproved')), onPostDeclined(post => router(post, 'onDeclined')), onPostFlagged(post => router(post, 'onFlagged')), onPostUnflagged(post => router(post, 'onUnflagged')), onPostReactionAdded(post => router(post, 'onReactionAdded')), onPostReactionRemoved(post => router(post, 'onReactionRemoved')));
     return () => {
         log(`observePosts(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -4693,100 +5432,28 @@ const observePost = (postId, callback, policy = 'cache_then_server') => {
     log(`observePost(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.postId) !== postId)
-            return;
+        var _a, _b;
         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);
+            (_a = callback.onEvent) === null || _a === void 0 ? void 0 : _a.call(callback, action, result);
+        (_b = callback[action]) === null || _b === void 0 ? void 0 : _b.call(callback, result);
+    };
+    const realtimeRouter = (result, action) => {
+        var _a;
+        if (((_a = result.data) === null || _a === void 0 ? void 0 : _a.postId) !== postId)
+            return;
+        router(result, action);
     };
     const disposers = [];
-    disposers.push(onPostUpdated(data => router({ data }, 'onUpdate')), onPostDeleted(data => router({ data }, 'onDelete')));
-    runQuery(createQuery(getPost, postId), (result) => result.data && router(result, 'onFetch'), queryOptions(policy));
+    disposers.push(onPostUpdated(data => realtimeRouter({ data }, 'onUpdate')), onPostDeleted(data => realtimeRouter({ data }, 'onDelete')), onPostApproved(data => realtimeRouter({ data }, 'onApproved')), onPostDeclined(data => realtimeRouter({ data }, 'onDeclined')), onPostFlagged(data => realtimeRouter({ data }, 'onFlagged')), onPostUnflagged(data => realtimeRouter({ data }, 'onUnflagged')), onPostReactionAdded(data => realtimeRouter({ data }, 'onReactionAdded')), onPostReactionRemoved(data => realtimeRouter({ data }, 'onReactionRemoved')));
+    runQuery(createQuery(getPost, postId), (result) => router(result, 'onFetch'), queryOptions(policy));
     return () => {
         log(`observePosts(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
     };
 };
 
-/**
- * ```js
- * import { onCommentCreated } from '@amityco/ts-sdk'
- * const dispose = onCommentCreated(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.Comment} has been created
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Comment Events
- */
-const onCommentCreated = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.comments[0]);
-    };
-    return createEventSubscriber(client, 'message/onCommentCreated', 'v3.comment.didCreate', filter);
-};
-
-/**
- * ```js
- * import { onCommentUpdated } from '@amityco/ts-sdk'
- * const dispose = onCommentUpdated(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.Comment} has been updated
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Comment Events
- */
-const onCommentUpdated = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.comments[0]);
-    };
-    return createEventSubscriber(client, 'message/onCommentUpdated', 'v3.comment.didUpdate', filter);
-};
-
-/**
- * ```js
- * import { onCommentDeleted } from '@amityco/ts-sdk'
- * const dispose = onCommentDeleted(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.Comment} has been deleted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Comment Events
- */
-const onCommentDeleted = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        decoratePayload(payload);
-        ingestInCache(payload);
-        callback(payload.comments[0]);
-    };
-    return createEventSubscriber(client, 'message/onCommentDeleted', 'v3.comment.didDelete', filter);
-};
-
 /**
  * ```js
  * import { observeComments } from '@amityco/ts-sdk'
@@ -4817,7 +5484,7 @@ const observeComments = (postId, callback) => {
         (_a = callback.onEvent) === null || _a === void 0 ? void 0 : _a.call(callback, action, comment);
         (_b = callback[action]) === null || _b === void 0 ? void 0 : _b.call(callback, comment);
     };
-    disposers.push(onCommentCreated(comment => router(comment, 'onCreate')), onCommentUpdated(comment => router(comment, 'onUpdate')), onCommentDeleted(comment => router(comment, 'onDelete')));
+    disposers.push(onCommentCreated(comment => router(comment, 'onCreate')), onCommentUpdated(comment => router(comment, 'onUpdate')), onCommentDeleted(comment => router(comment, 'onDelete')), onCommentFlagged(comment => router(comment, 'onFlagged')), onCommentUnflagged(comment => router(comment, 'onUnflagged')), onCommentReactionAdded(comment => router(comment, 'onReactionAdded')), onCommentReactionRemoved(comment => router(comment, 'onReactionRemoved')));
     return () => {
         log(`observeComments(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -4846,19 +5513,22 @@ const observeComment = (commentId, callback, policy = 'cache_then_server') => {
     log(`observeComment(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.commentId) !== commentId)
-            return;
+        var _a, _b;
         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);
+            (_a = callback.onEvent) === null || _a === void 0 ? void 0 : _a.call(callback, action, result);
+        (_b = callback[action]) === null || _b === void 0 ? void 0 : _b.call(callback, result);
+    };
+    const realtimeRouter = (result, action) => {
+        var _a;
+        if (((_a = result.data) === null || _a === void 0 ? void 0 : _a.commentId) !== commentId)
+            return;
+        router(result, action);
     };
     const disposers = [];
-    disposers.push(onCommentUpdated(data => router({ data }, 'onUpdate')), onCommentDeleted(data => router({ data }, 'onDelete')));
-    runQuery(createQuery(getComment, commentId), result => result.data && router(result, 'onFetch'), queryOptions(policy));
+    disposers.push(onCommentUpdated(data => realtimeRouter({ data }, 'onUpdate')), onCommentDeleted(data => realtimeRouter({ data }, 'onDelete')), onCommentFlagged(data => realtimeRouter({ data }, 'onFlagged')), onCommentUnflagged(data => realtimeRouter({ data }, 'onUnflagged')), onCommentReactionAdded(data => realtimeRouter({ data }, 'onReactionAdded')), onCommentReactionRemoved(data => realtimeRouter({ data }, 'onReactionRemoved')));
+    runQuery(createQuery(getComment, commentId), result => router(result, 'onFetch'), queryOptions(policy));
     return () => {
         log(`observeComment(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -5058,4 +5728,4 @@ const disposeStream = async (streamId) => {
     return videoStreamings.find(stream => stream.streamId === streamId);
 };
 
-export { VERSION$1 as VERSION, addChannelMembers, addChannelMembersRole, addCommunityMembers, addCommunityMembersRole, addReaction, clearCache, connectClient, createCache, createChannel, createClient, createComment, createCommunity, createFile, createMessage, createPost, createQuery, createReport, createStream, decorateModel, decorateModels, decoratePayload, deleteChannel, deleteComment, deleteCommunity, deleteFile, deleteMessage, deletePost, deleteReport, deleteStream, disconnectClient, disposeStream, dropFromCache, enableCache, fileUrlWithSize, filterByPropEquality, getActiveClient, getChannel, getChannels, getComment, getComments, getCommunities, getCommunity, getFile, getMessage, getMessages, getPost, getPosts, getRole, getStream, getUser, getUsers, ingestInCache, isAfterBefore, isConnected, isFetcher, isFresh, isLocal, isMutator, isOffline, isPaged, isReportedByMe, isSkipLimit, isSyncable, isSynced, joinChannel, joinCommunity, leaveChannel, leaveCommunity, memoryStore, memoryStores, mergeInCache, mutateCache, observeChannel, observeComment, observeComments, observeCommunity, observeFile, observeMessage, observeMessages, observePost, observePosts, observeUser, onChannelDeleted, onChannelJoined, onChannelLeft, onChannelUpdated, onClientBanned, onClientDisconnected, onCommentCreated, onCommentDeleted, onCommentUpdated, onCommunityCreated, onCommunityDeleted, onCommunityJoined, onCommunityLeft, onCommunityUpdated, onConnectionError, onMemberAdded, onMemberRemoved, onMessageCreated, onMessageDeleted, onMessageUpdated, onPostCreated, onPostDeleted, onPostUpdated, onReactionRemoved, onUserUpdated, persistentStore, pullFromCache, pushToCache, queryChannelMembers, queryChannels, queryComments, queryCommunities, queryCommunityMembers, queryGlobalFeed, queryMessages, queryOptions, queryPosts, queryRoles, queryStreams, queryUsers, removeChannelMembers, removeChannelMembersRole, removeCommunityMembers, removeCommunityMembersRole, removeReaction, runQuery, sliceByPaging, sortByChannelSegment, sortByDisplayName, sortByFirstCreated, sortByLastActivity, sortByLastCreated, sortBySegmentNumber, syncInCache, toPage, toToken, updateChannel, updateComment, updateCommunity, updateMessage, updatePost, updateStream, updateUser };
+export { SubscriptionLevels, VERSION$1 as VERSION, addChannelMembers, addChannelMembersRole, addCommunityMembers, addCommunityMembersRole, addReaction, clearCache, connectClient, createCache, createChannel, createClient, createComment, createCommunity, createFile, createMessage, createPost, createQuery, createReport, createStream, decorateModel, decorateModels, decoratePayload, deleteChannel, deleteComment, deleteCommunity, deleteFile, deleteMessage, deletePost, deleteReport, deleteStream, disconnectClient, disposeStream, dropFromCache, enableCache, fileUrlWithSize, filterByPropEquality, getActiveClient, getChannel, getChannels, getComment, getCommentTopic, getComments, getCommunities, getCommunity, getCommunityTopic, getFile, getMessage, getMessages, getPost, getPostTopic, getPosts, getRole, getStream, getUser, getUserTopic, getUsers, ingestInCache, isAfterBefore, isConnected, isFetcher, isFresh, isLocal, isMutator, isOffline, isPaged, isReportedByMe, isSkipLimit, isSyncable, isSynced, joinChannel, joinCommunity, leaveChannel, leaveCommunity, memoryStore, memoryStores, mergeInCache, mutateCache, observeChannel, observeComment, observeComments, observeCommunity, observeFile, observeMessage, observeMessages, observePost, observePosts, observeUser, onChannelDeleted, onChannelJoined, onChannelLeft, onChannelUpdated, onClientBanned, onClientDisconnected, onCommentCreated, onCommentDeleted, onCommentFlagged, onCommentReactionAdded, onCommentReactionRemoved, onCommentUnflagged, onCommentUpdated, onCommunityCreated, onCommunityDeleted, onCommunityJoined, onCommunityLeft, onCommunityUpdated, onCommunityUserAdded, onCommunityUserBanned, onCommunityUserRemoved, onCommunityUserUnbanned, onConnectionError, onMemberAdded, onMemberRemoved, onMessageCreated, onMessageDeleted, onMessageUpdated, onPostApproved, onPostCreated, onPostDeclined, onPostDeleted, onPostFlagged, onPostReactionAdded, onPostReactionRemoved, onPostUnflagged, onPostUpdated, onReactionRemoved, onUserFlagCleared, onUserFlagged, onUserUnflagged, onUserUpdated, persistentStore, pullFromCache, pushToCache, queryChannelMembers, queryChannels, queryComments, queryCommunities, queryCommunityMembers, queryGlobalFeed, queryMessages, queryOptions, queryPosts, queryRoles, queryStreams, queryUsers, removeChannelMembers, removeChannelMembersRole, removeCommunityMembers, removeCommunityMembersRole, removeReaction, runQuery, sliceByPaging, sortByChannelSegment, sortByDisplayName, sortByFirstCreated, sortByLastActivity, sortByLastCreated, sortBySegmentNumber, subscribeTopic, syncInCache, toPage, toToken, updateChannel, updateComment, updateCommunity, updateMessage, updatePost, updateStream, updateUser };