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

package/dist/index.cjs.js

@@ -2,28 +2,32 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var isMatchWith = require('lodash.ismatchwith');
 var jsBase64 = require('js-base64');
 var nativeIdGenerator = require('react-native-uuid');
 var debug = require('debug');
 var axios = require('axios');
 var HttpAgent = require('agentkeepalive');
 var io = require('socket.io-client');
+var mqtt = require('mqtt');
 var mitt = require('mitt');
 var AsyncStorage = require('@react-native-async-storage/async-storage');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+var isMatchWith__default = /*#__PURE__*/_interopDefaultLegacy(isMatchWith);
 var nativeIdGenerator__default = /*#__PURE__*/_interopDefaultLegacy(nativeIdGenerator);
 var debug__default = /*#__PURE__*/_interopDefaultLegacy(debug);
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var HttpAgent__default = /*#__PURE__*/_interopDefaultLegacy(HttpAgent);
 var io__default = /*#__PURE__*/_interopDefaultLegacy(io);
+var mqtt__default = /*#__PURE__*/_interopDefaultLegacy(mqtt);
 var mitt__default = /*#__PURE__*/_interopDefaultLegacy(mitt);
 var AsyncStorage__default = /*#__PURE__*/_interopDefaultLegacy(AsyncStorage);
 
 var _a;
 // used in createClient
-const VERSION$1 = (_a = 'v0.0.1-beta.8-cjs') !== null && _a !== void 0 ? _a : '__dev__';
+const VERSION$1 = (_a = 'v0.0.1-beta.9-cjs') !== null && _a !== void 0 ? _a : '__dev__';
 
 /**
  * Generic ASC error
@@ -290,24 +294,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
  *
@@ -339,6 +325,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__default['default'](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
@@ -769,6 +807,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
@@ -797,7 +874,7 @@ const stringify = (params, prefix) => {
  * @category Transport
  * @hidden
  */
-const createHttpTransport = (endpoint = 'https://api.amity.co') => {
+const createHttpTransport = (endpoint) => {
     const options = {
         maxSockets: 100,
         maxFreeSockets: 10,
@@ -818,7 +895,8 @@ const createHttpTransport = (endpoint = 'https://api.amity.co') => {
             unwrapPayload(response.data);
     });
     return instance;
-};
+};
+
 /**
  * Creates a pre-configured socket.io instance
  *
@@ -828,42 +906,19 @@ const createHttpTransport = (endpoint = 'https://api.amity.co') => {
  * @category Transport
  * @hidden
  */
-const createWebsocketTransport = (endpoint = 'https://api.ekomedia.technology') => {
+const createWebsocketTransport = (endpoint) => {
     const socket = io__default['default'](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)
  *
@@ -893,14 +948,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__default['default'].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',
@@ -913,6 +1085,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__default['default']();
@@ -928,10 +1109,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
  *
@@ -983,14 +1174,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}`,
@@ -998,6 +1190,7 @@ const createClient = (apiKey, apiEndpoint = 'https://api.amity.co', debugSession
         log,
         http,
         ws,
+        mqtt,
         emitter,
         use: () => setActiveClient(client),
     };
@@ -1010,6 +1203,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 */
@@ -1066,6 +1291,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'
@@ -1094,11 +1396,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
@@ -1107,41 +1410,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
@@ -1294,16 +1576,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
  *
@@ -1389,82 +1661,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();
-    });
-};
+exports.SubscriptionLevels = void 0;
+(function (SubscriptionLevels) {
+    SubscriptionLevels["COMMUNITY"] = "community";
+    SubscriptionLevels["POST"] = "post";
+    SubscriptionLevels["COMMENT"] = "comment";
+    SubscriptionLevels["POST_AND_COMMENT"] = "post_and_comment";
+    SubscriptionLevels["USER"] = "user";
+})(exports.SubscriptionLevels || (exports.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 = exports.SubscriptionLevels.COMMUNITY) => getCommunityUserTopic({ path }, level);
+const getUserTopic = ({ path }, level = exports.SubscriptionLevels.USER) => getCommunityUserTopic({ path }, level);
+const getPostTopic = ({ path }, level = exports.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
@@ -1666,6 +1907,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'
@@ -1674,22 +1925,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
@@ -1723,7 +2017,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`);
@@ -1987,10 +2281,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] });
 };
 
 /**
@@ -2523,8 +2817,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];
 };
@@ -2552,7 +2846,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);
 };
@@ -2722,7 +3016,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];
 };
@@ -2748,7 +3042,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);
 };
@@ -2773,7 +3067,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;
 };
 
@@ -2797,7 +3091,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;
@@ -2825,7 +3119,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;
@@ -2904,7 +3198,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;
@@ -2933,7 +3227,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;
@@ -3024,11 +3318,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 });
@@ -3276,8 +3570,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];
 };
@@ -3305,7 +3599,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);
 };
@@ -3338,8 +3632,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 });
@@ -3362,6 +3656,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'
@@ -3474,75 +3804,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;
 };
 
@@ -3564,9 +4287,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;
 };
 
@@ -4336,166 +5062,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
@@ -4519,19 +5332,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());
@@ -4568,81 +5384,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'
@@ -4678,7 +5419,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());
@@ -4707,100 +5448,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'
@@ -4831,7 +5500,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());
@@ -4860,19 +5529,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());
@@ -5112,17 +5784,21 @@ exports.getActiveClient = getActiveClient;
 exports.getChannel = getChannel;
 exports.getChannels = getChannels;
 exports.getComment = getComment;
+exports.getCommentTopic = getCommentTopic;
 exports.getComments = getComments;
 exports.getCommunities = getCommunities;
 exports.getCommunity = getCommunity;
+exports.getCommunityTopic = getCommunityTopic;
 exports.getFile = getFile;
 exports.getMessage = getMessage;
 exports.getMessages = getMessages;
 exports.getPost = getPost;
+exports.getPostTopic = getPostTopic;
 exports.getPosts = getPosts;
 exports.getRole = getRole;
 exports.getStream = getStream;
 exports.getUser = getUser;
+exports.getUserTopic = getUserTopic;
 exports.getUsers = getUsers;
 exports.ingestInCache = ingestInCache;
 exports.isAfterBefore = isAfterBefore;
@@ -5163,22 +5839,39 @@ exports.onClientBanned = onClientBanned;
 exports.onClientDisconnected = onClientDisconnected;
 exports.onCommentCreated = onCommentCreated;
 exports.onCommentDeleted = onCommentDeleted;
+exports.onCommentFlagged = onCommentFlagged;
+exports.onCommentReactionAdded = onCommentReactionAdded;
+exports.onCommentReactionRemoved = onCommentReactionRemoved;
+exports.onCommentUnflagged = onCommentUnflagged;
 exports.onCommentUpdated = onCommentUpdated;
 exports.onCommunityCreated = onCommunityCreated;
 exports.onCommunityDeleted = onCommunityDeleted;
 exports.onCommunityJoined = onCommunityJoined;
 exports.onCommunityLeft = onCommunityLeft;
 exports.onCommunityUpdated = onCommunityUpdated;
+exports.onCommunityUserAdded = onCommunityUserAdded;
+exports.onCommunityUserBanned = onCommunityUserBanned;
+exports.onCommunityUserRemoved = onCommunityUserRemoved;
+exports.onCommunityUserUnbanned = onCommunityUserUnbanned;
 exports.onConnectionError = onConnectionError;
 exports.onMemberAdded = onMemberAdded;
 exports.onMemberRemoved = onMemberRemoved;
 exports.onMessageCreated = onMessageCreated;
 exports.onMessageDeleted = onMessageDeleted;
 exports.onMessageUpdated = onMessageUpdated;
+exports.onPostApproved = onPostApproved;
 exports.onPostCreated = onPostCreated;
+exports.onPostDeclined = onPostDeclined;
 exports.onPostDeleted = onPostDeleted;
+exports.onPostFlagged = onPostFlagged;
+exports.onPostReactionAdded = onPostReactionAdded;
+exports.onPostReactionRemoved = onPostReactionRemoved;
+exports.onPostUnflagged = onPostUnflagged;
 exports.onPostUpdated = onPostUpdated;
 exports.onReactionRemoved = onReactionRemoved;
+exports.onUserFlagCleared = onUserFlagCleared;
+exports.onUserFlagged = onUserFlagged;
+exports.onUserUnflagged = onUserUnflagged;
 exports.onUserUpdated = onUserUpdated;
 exports.persistentStore = persistentStore;
 exports.pullFromCache = pullFromCache;
@@ -5208,6 +5901,7 @@ exports.sortByFirstCreated = sortByFirstCreated;
 exports.sortByLastActivity = sortByLastActivity;
 exports.sortByLastCreated = sortByLastCreated;
 exports.sortBySegmentNumber = sortBySegmentNumber;
+exports.subscribeTopic = subscribeTopic;
 exports.syncInCache = syncInCache;
 exports.toPage = toPage;
 exports.toToken = toToken;