@amityco/ts-sdk 0.0.1-02f0fa3.0

package/dist/index.cjs.js

@@ -0,0 +1,4884 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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 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 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 mitt__default = /*#__PURE__*/_interopDefaultLegacy(mitt);
+var AsyncStorage__default = /*#__PURE__*/_interopDefaultLegacy(AsyncStorage);
+
+/**
+ * Generic ASC error
+ * @category Errors
+ */
+class ASCError extends Error {
+    /**
+     * @param message A custom error message
+     * @param code A normalized error code
+     * @param level A normalized failure level descriptor
+     */
+    constructor(message, code, level) {
+        super(`Amity SDK (${code}): ${message}`);
+        this.code = code;
+        this.level = level;
+        this.type = 'ASC';
+        this.timestamp = Date.now();
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(this, ASCError);
+    }
+}
+/**
+ * API level error
+ * @category Errors
+ */
+class ASCApiError extends ASCError {
+    /**
+     * @param code A normalized error code
+     * @param level A normalized failure level descriptor
+     */
+    constructor(message, code, level) {
+        super(message, code, level);
+    }
+}
+/**
+ * Unexpected error
+ * @category Errors
+ */
+class ASCUnknownError extends ASCError {
+    /**
+     * @param code A normalized error code
+     * @param level A normalized failure level descriptor
+     */
+    constructor(code = 800000 /* UNKNOWN_ERROR */, level = "fatal" /* FATAL */) {
+        super('Unexpected error', code, level);
+    }
+}
+/**
+ * Network related error
+ * @category Errors
+ */
+class ASCConnectionError extends ASCError {
+    /**
+     * @param message A custom error message
+     */
+    constructor(message = 'SDK client is having connection issues') {
+        super(message, 800210 /* CONNECTION_ERROR */, "error" /* ERROR */);
+    }
+}
+
+let activeClient = null;
+/**
+ * Get the active client
+ *
+ * @returns the active client instance
+ *
+ * @hidden
+ */
+const getActiveClient = () => {
+    if (!activeClient) {
+        throw new ASCError('There is no active client', 800000 /* UNKNOWN_ERROR */, "fatal" /* FATAL */);
+    }
+    return activeClient;
+};
+/**
+ * Sets the active client
+ *
+ * @param client the client to assume as currently active client
+ *
+ * @hidden
+ */
+const setActiveClient = (client) => {
+    activeClient = client;
+};
+
+/**
+ * Pull objects from the cache layer
+ *
+ * @param name The name of the store to query
+ * @param keys A collection of unique keys for the store
+ * @returns The collection of objects matching the keys. Keys which don't match object will be omitted
+ *
+ * @category Cache
+ */
+const pullFromCache = (name, ...keys) => {
+    var _a;
+    const { cache } = getActiveClient();
+    const store = cache === null || cache === void 0 ? void 0 : cache[name];
+    if (!cache || !store)
+        return;
+    const state = (_a = store.read()) !== null && _a !== void 0 ? _a : {};
+    // return all
+    if (!(keys === null || keys === void 0 ? void 0 : keys.length))
+        return Object.values(state);
+    // return some
+    return keys
+        .map(key => {
+        const localId = cache.lookup[`${name}#${key}`];
+        return state[localId];
+    })
+        .filter(Boolean);
+};
+
+/**
+ * Dictionary of resolver functions for each model
+ * @hidden
+ */
+const idResolvers = {
+    user: ({ userId }) => userId,
+    file: ({ fileId }) => fileId,
+    role: ({ roleId }) => roleId,
+    channel: ({ channelId }) => channelId,
+    channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
+    message: ({ messageId }) => messageId,
+    community: ({ communityId }) => communityId,
+    communityUsers: ({ communityId, userId }) => `${communityId}#${userId}`,
+    post: ({ postId }) => postId,
+    comment: ({ commentId }) => commentId,
+    stream: ({ streamId }) => streamId,
+};
+/**
+ * Retrieve the id resolver matching a domain name
+ *
+ * @param name the domain name for the resolve
+ * @returns an idResolver for the given domain name
+ */
+const getResolver = (name) => idResolvers[name];
+/**
+ * A map of v3 response keys to a store name.
+ * @hidden
+ */
+const storeInterests = {
+    users: 'user',
+    files: 'file',
+    roles: 'role',
+    channels: 'channel',
+    channelUsers: 'channelUsers',
+    messages: 'message',
+    communities: 'community',
+    communityUsers: 'communityUsers',
+    posts: 'post',
+    postChildren: 'post',
+    comments: 'comment',
+};
+
+/**
+ * Pull objects from the cache layer
+ *
+ * @param name The name of the store to query
+ * @param models A collection of models t store
+ *
+ * @category Cache
+ */
+const pushToCache = (name, ...models) => {
+    const { cache } = getActiveClient();
+    const store = cache === null || cache === void 0 ? void 0 : cache[name];
+    if (!cache || !store)
+        return;
+    const filtered = models.filter(Boolean);
+    if (!filtered.length)
+        return;
+    const synced = Object.fromEntries(filtered.map(model => {
+        var _a;
+        var _b, _c;
+        const modelId = getResolver(name)(model);
+        const localId = ((_a = (_b = cache.lookup)[_c = `${name}#${modelId}`]) !== null && _a !== void 0 ? _a : (_b[_c] = model.localId));
+        // WARNING: shallow immutable
+        return [localId, Object.assign(Object.assign({ 
+                // @ts-ignore: syncedAt is before "...model" so it can be manually overridden
+                syncedAt: Date.now() }, model), { localId })];
+    }));
+    store.write(synced);
+};
+
+/**
+ * Pull objects from the cache layer
+ *
+ * @param name The name of the store to query
+ * @param keys A collection of unique keys for the store
+ * @returns The collection of objects matching the keys. Keys which don't match object will be omitted
+ *
+ * @category Cache
+ */
+const dropFromCache = (name, partial) => {
+    const { cache } = getActiveClient();
+    const store = cache === null || cache === void 0 ? void 0 : cache[name];
+    if (!cache || !store)
+        return [];
+    const modelId = getResolver(name)(partial);
+    const localId = cache.lookup[`${name}#${modelId}`];
+    delete cache.lookup[`${name}#${modelId}`];
+    store.erase(localId);
+};
+
+/** hidden */
+/** @hidden */
+const CRITERIAS = {
+    'file': ['fileId', 'attributes'],
+    'user': ['userId', 'avatarFileId'],
+    'role': ['roleId'],
+    'channel': ['channelId', 'rateLimit'],
+    'channelUsers': ['channelId', 'userId', 'membership'],
+    'message': ['messageId'],
+    'community': ['communityId', 'onlyAdminCanPost'],
+    'communityUsers': ['userId', 'communityId', 'communityMembership'],
+    'post': ['postId', 'feedId'],
+    'comment': ['commentId', 'referenceId'],
+    'stream': ['streamId'],
+};
+/** @hidden */
+const hasKeys = (object, needles) => {
+    const haystack = Object.keys(object);
+    return needles.every(needle => haystack.includes(needle));
+};
+/**
+ * Finds the name of the store for a given unknown model
+ *
+ * @param model one of the {@link Amity.Model} to identify
+ * @returns the name of the corresponding store
+ */
+const identifyModel = (model) => {
+    var _a;
+    const criterias = Object.entries(CRITERIAS);
+    return (_a = criterias.find(([_, keys]) => hasKeys(model, keys))) === null || _a === void 0 ? void 0 : _a[0];
+};
+
+/**
+ * Sync-up local ids of objects in the cache
+ *
+ * @param original The object holding the localId to keep
+ * @param replacement The object holding the localId to discard
+ *
+ * @category Cache
+ */
+const syncInCache = (original, replacement) => {
+    var _a;
+    const { cache, log } = getActiveClient();
+    const name = (_a = identifyModel(original)) !== null && _a !== void 0 ? _a : identifyModel(replacement);
+    if (!name) {
+        log('syncInCache', 'could not identify the models', { original, replacement });
+        return;
+    }
+    const store = cache === null || cache === void 0 ? void 0 : cache[name];
+    if (!cache || !store)
+        return;
+    // remove the object from cache (it's cleaner this way)
+    dropFromCache(name, original);
+    dropFromCache(name, replacement);
+    // glue the localIds together
+    replacement.localId = original.localId;
+    // put back the replacement after (again, it's cleaner this way)
+    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
+ *
+ * @param name The name of the store to query
+ * @param mutation A partial view of the object to update
+ *
+ * @category Cache
+ */
+const mutateCache = (name, key, mutator) => {
+    var _a;
+    const [model] = (_a = pullFromCache(name, key)) !== null && _a !== void 0 ? _a : [];
+    if (!model)
+        return;
+    const mutation = mutator(model);
+    mutation && pushToCache(name, Object.assign(Object.assign({}, model), mutation));
+    return mutation;
+};
+
+/**
+ * Apply partial mutation to objects in the cache
+ *
+ * @param name The name of the store to query
+ * @param mutation A partial view of the object to update
+ *
+ * @category Cache
+ */
+const mergeInCache = (name, mutation) => {
+    const key = getResolver(name)(mutation);
+    mutateCache(name, key, model => (Object.assign(Object.assign({}, model), mutation)));
+};
+
+/**
+ * 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
+ * in the SDK.
+ *
+ * @param stores A partial collection of stores
+ * @returns A cache instance
+ *
+ * @category Cache
+ */
+const createCache = (stores) => {
+    const lookup = {};
+    return Object.assign({ lookup }, stores);
+};
+
+// @ts-ignore
+/**
+ * Type guard to find if the a given decoded backend token uses "skip/limit" pagination style
+ *
+ * @param json any json object as extracted from the backend
+ * @returns success boolean if the token has either "skip" or "limit" props
+ *
+ * @hidden
+ */
+const isSkipLimit = (json) => (['skip', 'limit'].some(prop => prop in json));
+/**
+ * Type guard to find if the a given decoded backend token uses "after/before" pagination style
+ *
+ * @param json any json object as extracted from the backend
+ * @returns success boolean if the token has either "after" or "before" props
+ *
+ * @hidden
+ */
+const isAfterBefore = (json) => (['after', 'before', 'first', 'last'].some(prop => prop in json));
+/**
+ * Type guard to find if the a given object is wrapped around Amity.Paged<>
+ *
+ * @param payload any object as passed from query functions
+ * @returns success boolean if the object is an array shaped as [Record<string, Amity.Syncable>, Amity.Pages]
+ *
+ * @hidden
+ */
+const isPaged = (payload) => {
+    return ((payload === null || payload === void 0 ? void 0 : payload.hasOwnProperty('data'))
+        && (payload === null || payload === void 0 ? void 0 : payload.hasOwnProperty('nextPage'))
+        && (payload === null || payload === void 0 ? void 0 : payload.hasOwnProperty('prevPage')));
+};
+/**
+ * Converts a paging object into a b64 string token
+ *
+ * @param paging the sdk-friendly paging object
+ * @param style the style of token to produce
+ * @returns a backend's b64 encoded token
+ *
+ * @hidden
+ */
+const toToken = (paging, style) => {
+    var _a;
+    if (!paging || !Object.keys(paging).length)
+        return;
+    let payload = {};
+    // TODO: refactor this clean
+    if (style === 'skiplimit') {
+        payload = {
+            skip: (_a = paging.after) !== null && _a !== void 0 ? _a : 0,
+            limit: paging.limit,
+        };
+    }
+    else if (style === 'afterbefore') {
+        /*
+          Caution: this testing style is only valid because
+          our backend expects nothing else than a number as
+          "before" or "after" value. if that would change,
+          we'd need to move toward a more simple: `!paging.before`
+        */
+        if (!isNaN(paging === null || paging === void 0 ? void 0 : paging.before)) {
+            payload = {
+                before: paging.before,
+                last: paging.limit,
+            };
+        }
+        else if (!isNaN(paging === null || paging === void 0 ? void 0 : paging.after)) {
+            payload = {
+                after: paging.after,
+                first: paging.limit,
+            };
+        }
+    }
+    // avoid sending {} as it seems backend flips when we do
+    if (!Object.keys(payload).length)
+        return;
+    // don't try catch, let it throw
+    return jsBase64.encode(JSON.stringify(payload));
+};
+/**
+ * Converts a b64 string token into a paging object
+ *
+ * @param token the backend's b64 encoded token
+ * @returns a sdk-friendly paging object
+ *
+ * @hidden
+ */
+const toPage = (token) => {
+    if (!token)
+        return null;
+    // don't try catch, let it throw
+    const json = JSON.parse(jsBase64.decode(token));
+    if (isSkipLimit(json)) {
+        return {
+            after: json.skip,
+            limit: json.limit,
+        };
+    }
+    else if (isAfterBefore(json)) {
+        if ('before' in json) {
+            return {
+                before: json.before,
+                limit: json.last,
+            };
+        }
+        else if ('after' in json) {
+            return {
+                after: json.after,
+                limit: json.first,
+            };
+        }
+    }
+    return null;
+};
+/**
+ * Slices a collection according to its paging
+ *
+ * @param type the type of collection (for unique id identification with after/before)
+ * @param collection the collection to slice
+ * @param paging the paging object
+ * @returns the sliced collection according to the paging definition
+ *
+ * @hidden
+ */
+const sliceByPaging = (type, collection, page) => {
+    console.log('slice by paging', page);
+    if (!page)
+        return collection.slice();
+    let start = 0;
+    let end = undefined;
+    // next page behavior
+    if (page.after) {
+        start = page.after;
+        end = start + page.limit;
+        // prev page behavior
+    }
+    else if (page.before) {
+        end = page.before + 1;
+        start = end > page.limit ? end - page.limit : 0;
+    }
+    const paged = collection.slice(start, end);
+    return paged.length === page.limit ? paged : undefined;
+};
+
+/**
+ * Type guard to check and cast that a given async function is has the ".locally" property
+ *
+ * @param func any SDK APi function
+ * @returns success boolean if the function has a 'locally' twin
+ *
+ * @hidden
+ */
+const isFetcher = (func) => ('locally' in func);
+/**
+ * Type guard to check and cast that a given async function is has the ".optimistically" property
+ *
+ * @param func any SDK APi function
+ * @returns success boolean if the function has an 'optimistically' twin
+ *
+ * @hidden
+ */
+const isMutator = (func) => ('optimistically' in func);
+/**
+ * Type guard to check and cast that a given async function is has
+ * the ".locally" or ".optimistically" property
+ *
+ * @param func any SDK APi function
+ * @returns success boolean if the function has an offline twin
+ *
+ * @hidden
+ */
+const isOffline = (func) => isFetcher(func) || isMutator(func);
+/**
+ * Type guard to check and cast that a given object has the "syncedAt" property
+ *
+ * @param model any object to check on
+ * @returns success boolean if the object has property "syncedAt"
+ *
+ * @hidden
+ */
+const isSyncable = (model) => (model === null || model === void 0 ? void 0 : model.hasOwnProperty('syncedAt'));
+/**
+ * Checks if a model is considered local (syncedAt === -1)
+ *
+ * @param model any syncable object to check
+ * @returns success boolean if the object is marked as local
+ *
+ * @hidden
+ */
+const isLocal = (model) => {
+    return isSyncable(model) && (model === null || model === void 0 ? void 0 : model.syncedAt) === -1;
+};
+/**
+ * Checks if a model is considered fresh
+ *
+ * @param model any syncable object to check
+ * @param lifeSpan the supposedly duration for which the object is considered synced
+ * @returns success boolean if the object is below the given lifespan
+ *
+ * @hidden
+ */
+const isFresh = (model, lifeSpan = 0) => {
+    var _a;
+    return Date.now() - ((_a = model === null || model === void 0 ? void 0 : model.syncedAt) !== null && _a !== void 0 ? _a : 0) <= lifeSpan;
+};
+/**
+ * Checks if a model is considered synced
+ *
+ * @param model any syncable object to check
+ * @param lifeSpan the supposedly duration for which the object is considered synced
+ * @returns success boolean if the object is local or below the given lifespan
+ *
+ * @hidden
+ */
+const isSynced = (model, lifeSpan = 0) => {
+    return isLocal(model) || isFresh(model, lifeSpan);
+};
+/**
+ * ```js
+ * import { createQuery, getUser } from '@amityco/ts-sdk'
+ * const query = createQuery(getUser, 'foobar')
+ * ```
+ *
+ * Creates a wrapper for the API call you wish to call.
+ * This wrapper is necessary to create for optimistically calls
+ *
+ *
+ * @param fn A compatible API function from the ts sdk
+ * @param args The arguments to pass to the function passed as `fn`
+ * @returns A wrapper containing both the function and its future arguments
+ *
+ * @category Query
+ */
+const createQuery = (func, ...args) => ({ func, args });
+/**
+ * ```js
+ * import { queryOptions } from '@amityco/ts-sdk'
+ * const options = queryOptions('no_fetch', lifeSpan)
+ * ```
+ *
+ * Creates a query options object based on the query policy passed
+ *
+ * @param policy The policy to apply to a query
+ * @returns A properly set query options object
+ *
+ * @category Query
+ */
+const queryOptions = (policy, lifeSpan = 2 * 60 * 1000) => {
+    if (policy === 'cache_only')
+        return { lifeSpan: Infinity };
+    else if (policy === 'server_only')
+        return { lifeSpan: 0 };
+    return { lifeSpan };
+};
+/**
+ * Checks if an unknown shaped payload is considered empty or not.
+ * Since the payload can be wrapped around [] or {} (query or get many),
+ * we need a smarter definition of what's considered "empty".
+ *
+ * @param local the unknown object to check for emptiness
+ * @returns true if the mixed-shape "local" content is considered empty
+ *
+ * @hidden
+ */
+const isEmpty = (local) => {
+    // if it's supposed to be a single object, it'd be undefined
+    if (!local)
+        return true;
+    // it's a paged query, the 1st cell of the array would be empty
+    else if (isPaged(local) && isEmpty(local.data)) {
+        return true;
+    }
+    // if it's a item collection, it'd have no keys
+    else if (!Object.keys(local).length)
+        return true;
+    return false;
+};
+/**
+ * Checks if an unknown shaped payload is considered synced or not.
+ * The object will first be identified by 3 types of shapes:
+ *
+ * 1. Amity.Paged<Amity.Syncable>
+ * 2. Amity.Syncable
+ * 3. Record<string, Amity.Syncable>
+ *
+ * then the "Syncable" component will be extracted and evaluated against
+ * the query options' lifeSpan value.
+ *
+ * @param local the unknown object to check for freshness
+ * @param options query options (for lifeSpan checking)
+ * @returns true if the mixed-shape "local" content is considered fresh
+ *
+ * @hidden
+ */
+const shouldAbort = (local, options) => {
+    // it's a paged query
+    if (isPaged(local) && shouldAbort(local.data, options)) {
+        return true;
+    }
+    // if it's object let's try to see if it's Amity.Syncable first
+    else if (isSynced(local, options.lifeSpan)) {
+        return true;
+    }
+    // otherwise consider as Record<string, Amity.Syncable>
+    else if (Object.values(local).length > 0 &&
+        Object.values(local).every(item => isSynced(item, options.lifeSpan))) {
+        return true;
+    }
+    return false;
+};
+/**
+ * ```js
+ * import { createQuery, getUser, runQuery } from '@amityco/ts-sdk'
+ * const query = createQuery(getUser, client, 'foobar')
+ * runQuery(query,  user => console.log(user))
+ * ```
+ *
+ * Calls an API function wrapped around a Amity.Query, and executes the callback whenever
+ * a value is available. The value can be picked either from the local cache and/or
+ * from the server afterwards depending on the query options passed
+ *
+ * @param query A query object wrapping the call to be made
+ * @param callback A function to execute when a value is available
+ * @param options the query options
+ *
+ * @category Query
+ */
+const runQuery = ({ func, args }, callback, options = queryOptions('cache_then_server')) => {
+    if (!isOffline(func) || options.lifeSpan === 0) {
+        callback === null || callback === void 0 ? void 0 : callback(wrap(undefined, {
+            origin: 'server',
+            loading: true
+        }));
+        func(...args)
+            .then(fresh => {
+            callback === null || callback === void 0 ? void 0 : callback(wrap(fresh, {
+                origin: 'server',
+                loading: false,
+            }));
+        })
+            .catch(error => {
+            callback === null || callback === void 0 ? void 0 : callback(wrap(undefined, {
+                error,
+                loading: false,
+            }));
+        });
+        return;
+    }
+    const local = isMutator(func)
+        ? func.optimistically(...args)
+        : func.locally(...args);
+    if (!isEmpty(local)) {
+        callback === null || callback === void 0 ? void 0 : callback(wrap(local, { origin: 'local' }));
+    }
+    if (local && isFetcher(func) && shouldAbort(local, options))
+        return;
+    callback === null || callback === void 0 ? void 0 : callback(wrap(local, {
+        origin: 'local',
+        loading: true,
+    }));
+    func(...args)
+        .then(fresh => {
+        // @ts-ignore i know.
+        isLocal(local) && syncInCache(local, fresh);
+        callback === null || callback === void 0 ? void 0 : callback(wrap(fresh, {
+            origin: 'server',
+            loading: false
+        }));
+    })
+        .catch(error => {
+        callback === null || callback === void 0 ? void 0 : callback(wrap(local, {
+            error,
+            loading: false,
+        }));
+    });
+};
+/**
+ *
+ * @param data
+ * @param meta
+ * @returns
+ */
+const wrap = (data, meta = {}) => {
+    if (isPaged(data))
+        return Object.assign(Object.assign({}, meta), data);
+    return Object.assign(Object.assign({}, meta), { data });
+};
+
+const uuid = () => nativeIdGenerator__default['default'].v4().toString();
+
+/**
+ * Creates a pre-configured logger instance
+ *
+ * @param session The name of the debug session
+ * @returns A pre-configured logger function
+ *
+ * @category Debug
+ * @hidden
+ */
+const createLogger = (session) => {
+    const active = (`${session === null || session === void 0 ? void 0 : session.trim()}`.length > 0
+        && process.env.NODE_ENV !== 'production');
+    const logger = debug__default['default'](session);
+    const print = (topic, ...args) => {
+        active && logger(topic, args);
+    };
+    print.__instance__ = logger;
+    return print;
+};
+
+/**
+ * Axios param serializer (for querystring)
+ * @hidden
+ */
+const stringify = (params, prefix) => {
+    return Object.entries(params)
+        .filter(([, value]) => value !== undefined)
+        .map(([name, value]) => {
+        const key = prefix ? `${prefix}[${name}]` : name;
+        if (Array.isArray(value)) {
+            return value.map(item => `${key}[]=${item}`).join('&');
+        }
+        else if (typeof value !== 'object') {
+            return `${key}=${value}`;
+        }
+        return stringify(value, prefix !== null && prefix !== void 0 ? prefix : name);
+    })
+        .join('&');
+};
+/**
+ * Creates a pre-configured axios instance
+ *
+ * @param endpoint The ASC rest api server's URL
+ * @returns A pre-configured axios instance
+ *
+ * @category Transport
+ * @hidden
+ */
+const createHttpTransport = (endpoint = 'https://api.amity.co') => {
+    const options = {
+        maxSockets: 100,
+        maxFreeSockets: 10,
+        timeout: 60000,
+        freeSocketTimeout: 30000,
+    };
+    const instance = axios__default['default'].create({
+        baseURL: endpoint,
+        httpAgent: new HttpAgent__default['default'](options),
+        httpsAgent: new HttpAgent.HttpsAgent(options),
+        paramsSerializer: stringify,
+    });
+    instance.interceptors.response.use((response) => response, (error) => {
+        var _a;
+        const { response } = error;
+        console.error((_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : error);
+        if (response)
+            unwrapPayload(response.data);
+    });
+    return instance;
+};
+/**
+ * Creates a pre-configured socket.io instance
+ *
+ * @param endpoint The socket.io server's URL
+ * @returns A pre-configured (non-connected) socket.io client instance
+ *
+ * @category Transport
+ * @hidden
+ */
+const createWebsocketTransport = (endpoint = 'https://api.ekomedia.technology') => {
+    const socket = io__default['default'](endpoint, {
+        autoConnect: false,
+        reconnectionDelay: 2000,
+        transports: ['websocket'],
+    });
+    socket.on('disconnect', (reason) => {
+        if (reason === 'io server disconnect')
+            socket.connect();
+    });
+    ['error', 'connect_error', 'connect_timeout', 'reconnect_error', 'reconnect_failed'].forEach(event => {
+        socket.on(event, (error) => {
+            throw new ASCConnectionError(`socket.io(${event}): ${error.message}`);
+        });
+    });
+    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)
+ *
+ * @param client The current client for which to send the event with
+ * @param event The websocket event name
+ * @param data The event's payload
+ *
+ * @returns The data returned by the backend
+ * @throws An error related to backend's rejection
+ *
+ * @category Transport
+ * @async
+ * @hidden
+ */
+const synchronousWSCall = async (client, event, data) => {
+    const { ws } = client;
+    const value = await new Promise((resolve, reject) => {
+        ws.emit(event, data, (response) => {
+            try {
+                resolve(unwrapPayload(response));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+    return value;
+};
+
+// need to sync up the list
+const EVENTS = [
+    'disconnected',
+    'v3.user.didUpdate',
+    'v3.channel.didUpdate',
+    'v3.channel.didUpdate',
+    'v3.channel.didJoin',
+    'v3.channel.didLeave',
+    'v3.channel.didAddUsers',
+    'v3.channel.didRemoveUsers',
+    'v3.channel.didBan',
+    'v3.channel.didUnban',
+    'v3.message.didCreate',
+    'v3.message.didUpdate',
+    'v3.message.didDelete',
+];
+/** @hidden */
+const createEventEmitter = () => {
+    return mitt__default['default']();
+};
+/**
+ * Wraps the websocket events into the client's event emitter for
+ * abstraction of transport.
+ *
+ * @param ws A websocket connection to listen from
+ * @param emitter An event emitter to wire the events to
+ *
+ * @category Transport
+ * @hidden
+ */
+const proxyWebsocketEvents = (ws, emitter) => {
+    EVENTS.forEach(event => {
+        ws.on(event, (param) => emitter.emit(event, param));
+    });
+};
+/**
+ * Standardize the subscription of SSE through web sockets
+ *
+ * @param client The current client for which to subscribe the event to
+ * @param namespace A unique name for the logger
+ * @param event The websocket event name
+ * @param fn A wrapper for the callback.
+ * @returns A dispose function to unsubscribe to the event
+ *
+ * @category Transport
+ * @hidden
+ */
+const createEventSubscriber = (client, namespace, event, fn) => {
+    const { log, emitter } = client;
+    const timestamp = Date.now();
+    log(`${namespace}(tmpid: ${timestamp}) > listen`);
+    const handler = (...payload) => {
+        log(`${namespace}(tmpid: ${timestamp}) > trigger`, payload);
+        fn(...payload);
+    };
+    emitter.on(event, handler);
+    return () => {
+        log(`${namespace}(tmpid: ${timestamp}) > dispose`);
+        emitter.off(event, handler);
+    };
+};
+/**
+ * Wrapper around dispatch event
+ *
+ * @hidden
+ */
+const fireEvent = (event, payload) => {
+    const { emitter } = getActiveClient();
+    setTimeout(() => { emitter.emit(event, payload); }, 0);
+};
+
+/**
+ * ```js
+ * import { createClient } from '@amityco/ts-sdk'
+ * const client = createClient(apiKey, 'https://asc.server/', 'myClient')
+ * ```
+ *
+ * Creates a new {@link Amity.Client} instance
+ *
+ * @param apiKey for the {@link Amity.Client} instance
+ * @param apiEndpoint endpoint to connect to
+ * @param debugSession session's identifier for the client's logger instance
+ * @returns A {@link Amity.Client} instance
+ *
+ * @category Client API
+ **/
+const createClient = (apiKey, apiEndpoint = 'https://api.amity.co', 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 emitter = createEventEmitter();
+    const client = {
+        apiKey, log, http, ws, emitter,
+        use: () => setActiveClient(client),
+    };
+    try {
+        getActiveClient();
+    }
+    catch (_a) {
+        setActiveClient(client);
+    }
+    return client;
+};
+
+// TODO: find a way to uniquely identify the device
+// import { getStorage } from './storage'
+/** @hidden */
+const VERSION = '11.0.0';
+/** @hidden */
+const getDeviceId = () => {
+    // here maybe put some auto detection of the device id based on if it's react or not?
+    // anyhow we let consumer branch out if they want, but it doesn't mean we shouldn't try to be nice
+    // and do things automatically
+    // https://www.npmjs.com/package/react-native-device-info#getuniqueid
+    // how to make sure that the react native package will not be included when build is for web
+    return `ascWebSdk#${Math.random().toString(16)}`;
+};
+/** @hidden */
+const getDeviceModel = () => {
+    var _a, _b;
+    if ((_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node)
+        return process.versions.node;
+    if (navigator)
+        return `${navigator.product.toLowerCase()}#${(_b = navigator.userAgent) !== null && _b !== void 0 ? _b : 'unknown_agent'}`;
+    return 'unknown_model';
+};
+/** @hidden */
+const getDeviceInfo = () => {
+    const model = getDeviceModel();
+    return {
+        version: VERSION,
+        // TODO: replace with: kind: process.versions ? 'node' : 'web', when backend has fixed this
+        kind: 'web',
+        model,
+    };
+};
+
+/**
+ * Retrieves a pair of {@link Amity.Tokens} necessary for connection
+ *
+ * @param userId The userId to use to issue a token
+ * @param displayName The user's displayName
+ * @param deviceId The user's device Id (can be manually set for native users)
+ * @param authToken The authentication token - necessary when network option is set to secure
+ * @return The accessToken for the given userId
+ *
+ * @category Client API
+ * @hidden
+ */
+const getToken = async (params) => {
+    const client = getActiveClient();
+    client.log('client/api/getToken', params);
+    const deviceInfo = await getDeviceInfo();
+    const { data } = await client.http.post('/v1/device', Object.assign(Object.assign({}, params), { deviceInfo }), {
+        headers: { 'X-API-Key': client.apiKey }
+    });
+    return data;
+};
+
+/**
+ * ```js
+ * import { connectClient } from '@amityco/ts-sdk/client/api'
+ * const success = await connectClient({
+ *   userId: 'XYZ123456789',
+ * })
+ * ```
+ *
+ * Connects an {@link Amity.Client} instance to ASC servers
+ *
+ * @param userId the user ID for the current session
+ * @param displayName the user's displayName for the current session
+ * @param deviceId Manual override of the user's device id (for device management)
+ * @param authToken The authentication token - necessary when network option is set to secure
+ * @returns a success boolean if connected
+ *
+ * @category Client API
+ * @async
+ */
+const connectClient = async (params) => {
+    var _a, _b;
+    const client = getActiveClient();
+    client.log('client/api/connectClient', Object.assign({ apiKey: client.apiKey }, params));
+    // default values
+    (_a = params.displayName) !== null && _a !== void 0 ? _a : (params.displayName = params.userId);
+    (_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);
+    // 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 };
+    // 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
+    // to be connected "on demand" rather than "by default"
+    await new Promise(resolve => {
+        client.ws.once('connect', resolve);
+        client.ws.open();
+    });
+    client.userId = params.userId;
+    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()
+ * ```
+ *
+ * Checks if a {@link Amity.Client} instance is connected to ASC servers
+ *
+ * @returns a success boolean if connected
+ *
+ * @category Client API
+ */
+const isConnected = () => {
+    var _a, _b;
+    const client = getActiveClient();
+    client.log('client/api/isConnected', client);
+    return !!(client.userId
+        && ((_b = (_a = client.http.defaults.headers.common) === null || _a === void 0 ? void 0 : _a['Authorization']) === null || _b === void 0 ? void 0 : _b.length)
+        && client.ws.connected);
+};
+
+/**
+ * Minimal store implementation.
+ *
+ * Beware, the state is mutable! it is your responsibility
+ * handle the state's mutations correctly. We do so in
+ * order for users with mutable/observable stacks to be able
+ * to decorate the state with their favorite libraries.
+ *
+ * @param defaultValue the hydration state value of the store
+ * @returns A store instance with an "in memory" storage strategy
+ *
+ * @category Storage
+ * @hidden
+ */
+const memoryStore = (defaultValue = {}) => {
+    const state = defaultValue;
+    /* default read operation is just to return the state */
+    const read = () => state;
+    /* default write operation is just to mutate the state */
+    const write = (payload) => {
+        Object.assign(state, payload);
+    };
+    /* default write operation is just to mutate the state */
+    const erase = (...keys) => {
+        if (!keys.length)
+            keys = Object.keys(state);
+        keys.forEach(key => delete state[key]);
+    };
+    return { read, write, erase };
+};
+/**
+ * ```js
+ * import { memoryStores } from '@amityco/core/cache/store/volatile'
+ * const stores = imemoryStores('user', 'file')
+ * ```
+ *
+ * Builds a collection of in memory stores based on the available store names
+ *
+ * @param names collection of store names
+ * @returns a dictionary of { storeName: storeInstance } according to the given names
+ *
+ * @category Storage
+ */
+const memoryStores = (...names) => {
+    return names.reduce((acc, name) => {
+        const store = memoryStore();
+        return Object.assign(Object.assign({}, acc), { [name]: store });
+    }, {});
+};
+
+const DEFAULT_DEBOUNCE_TIME = 250;
+/**
+ * Persistent store implementation.
+ *
+ * @param persistentKey the name of the store in persistent storage
+ * @param defaultValue the hydration state value of the store
+ * @param debounceTime a delay to avoid spamming the persistent storage while writing,
+ * @returns A store instance with an "persistent" storage strategy
+ *
+ * @category Storage
+ * @hidden
+ */
+const persistentStore = async (persistentKey, defaultValue = {}, debounceTime = DEFAULT_DEBOUNCE_TIME) => {
+    let initialValue = defaultValue;
+    const serializedBackup = await AsyncStorage__default['default'].getItem(persistentKey);
+    if (serializedBackup) {
+        try {
+            initialValue = JSON.parse(serializedBackup);
+        }
+        catch (err) { }
+    }
+    // create a store
+    const store = memoryStore(initialValue);
+    let timer;
+    let job = null;
+    const backup = () => {
+        if (job) {
+            job.then(() => backup());
+            return;
+        }
+        clearTimeout(timer);
+        setTimeout(async () => {
+            job = Promise.resolve()
+                .then(() => AsyncStorage__default['default'].setItem(persistentKey, JSON.stringify(store.read())))
+                .then(() => job = null);
+        }, debounceTime);
+    };
+    const write = (payload) => {
+        store.write(payload);
+        backup();
+    };
+    const erase = (...keys) => {
+        store.erase(...keys);
+        backup();
+    };
+    return { read: store.read, write, erase };
+};
+
+/**
+ * ```js
+ * import { enableCache } from '@amityco/ts-sdk'
+ * enableCache()
+ * ```
+ *
+ * Adds a new {@link Amity.Cache} object to an {@link Amity.Client} instance
+ *
+ * @param stores a partial dictionary of stores to be used for caching
+ *
+ * @category Client API
+ */
+const enableCache = (stores = memoryStores('user', 'file', 'channel', 'message', 'community', 'post', 'comment', 'communityUsers', 'channelUsers')) => {
+    const client = getActiveClient();
+    client.log('client/api/enableCache');
+    client.cache = createCache(stores);
+};
+
+/**
+ * ```js
+ * import { clearCache } from '@amityco/ts-sdk'
+ * clearCache()
+ * ```
+ *
+ * Resets the state of the given {@link Amity.Store} names within
+ * the {@link Amity.Cache} object of a {@link Amity.Client} instance
+ *
+ * @param stores an array of the stores names to be wiped
+ *
+ * @category Client API
+ */
+const clearCache = (stores = ['user', 'file', 'channel', 'message', 'community', 'post', 'comment']) => {
+    const client = getActiveClient();
+    client.log('client/api/enableCache');
+    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
+ *
+ * @param model the model to decorate
+ * @param timestamp the given timestamp
+ */
+const decoratePayload = (payload, timestamp = Date.now(), keyMapping = storeInterests) => {
+    Object.fromEntries(Object.entries(payload)
+        .map(([key, models]) => ([
+        key, decorateModels(models, timestamp, keyMapping[key])
+    ])));
+};
+/**
+ * Set the model's syncedAt property and localId
+ *
+ * @param model the model to decorate
+ * @param timestamp the given timestamp
+ */
+const decorateModels = (models, timestamp = Date.now(), type) => {
+    models.forEach(model => decorateModel(model, timestamp, type));
+};
+/**
+ * Set the model's syncedAt property and localId
+ *
+ * @param model the model to decorate
+ * @param syncedAt the given timestamp
+ * @param type An opportunity to manually pass the type. If undefined, it will be smartly computed
+ */
+const decorateModel = (model, timestamp = Date.now(), type = identifyModel(model)) => {
+    var _a, _b;
+    (_a = model.syncedAt) !== null && _a !== void 0 ? _a : (model.syncedAt = timestamp);
+    const { cache } = getActiveClient();
+    if (type) {
+        const modelId = getResolver(type)(model);
+        model.localId = (_b = cache === null || cache === void 0 ? void 0 : cache.lookup[`${type}#${modelId}`]) !== null && _b !== void 0 ? _b : uuid();
+    }
+};
+
+// Note:
+// this file should contain a suite of filtering utilities to help the
+// local version of the query functions.
+/**
+ * Filter a given collection with strict equality against a param
+ *
+ * @param collection the collection to filter
+ * @param key the key of the collection's items to challenge
+ * @param value the expected value
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+const filterByPropEquality = (collection, key, value) => (value !== undefined ? collection.filter(item => item[key] === value) : collection);
+
+// Note:
+// this file should contain a suite of sorting utilities to help the
+// local version of the query functions.
+/**
+ * Alphabetic sorting of objects having a displayName
+ */
+const sortByDisplayName = ({ displayName: a }, { displayName: b }) => {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+};
+/**
+ * Sorting a collection by their apparition order (oldest first)
+ */
+const sortByChannelSegment = ({ channelSegment: a }, { channelSegment: b }) => a - b;
+/**
+ * Sorting a collection by their apparition order (oldest first)
+ */
+const sortBySegmentNumber = ({ segmentNumber: a }, { segmentNumber: b }) => a - b;
+/**
+ * Sorting a collection by its oldest items
+ */
+const sortByFirstCreated = ({ createdAt: a }, { createdAt: b }) => new Date(a).valueOf() - new Date(b).valueOf();
+/**
+ * Sorting a collection by its newest items
+ */
+const sortByLastCreated = ({ createdAt: a }, { createdAt: b }) => new Date(b).valueOf() - new Date(a).valueOf();
+/**
+ * Sorting a collection by the items with most recent activity
+ */
+const sortByLastActivity = ({ lastActivity: a }, { lastActivity: b }) => new Date(b).valueOf() - new Date(a).valueOf();
+
+/**
+ * ```js
+ * import { onClientDisconnected } from '@amityco/ts-sdk'
+ * const dispose = onClientDisconnected(reason => {
+ *   // ...
+ * })
+ * ```
+ *
+ * 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 createEventSubscriber(getActiveClient(), 'client/onClientDisconnected', 'disconnected', () => callback());
+};
+
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk'
+ * const user = await getUser('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category User API
+ * @async
+ */
+const getUser = async (userId) => {
+    const client = getActiveClient();
+    client.log('user/getUser', userId);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/users/${userId}`);
+    decoratePayload(data);
+    ingestInCache(data);
+    const { users } = data;
+    return users.find(user => user.userId === userId);
+};
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk'
+ * const user = getUser.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object from cache
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category User API
+ */
+getUser.locally = (userId) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('user/getUser.locally', userId);
+    const [user] = (_a = pullFromCache('user', userId)) !== null && _a !== void 0 ? _a : [];
+    return user;
+};
+
+/**
+ * ```js
+ * import { getUsers } from '@amityco/ts-sdk'
+ * const users = await getUsers(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.User} objects
+ *
+ * @param userIds the IDs of the {@link Amity.User} to fetch
+ * @returns the associated collection of {@link Amity.User} objects
+ *
+ * @category User API
+ * @async
+ */
+const getUsers = async (userIds) => {
+    const client = getActiveClient();
+    client.log('user/getUsers', userIds);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/users/list`, { params: { userIds } });
+    decoratePayload(data);
+    ingestInCache(data);
+    const { users } = data;
+    return toRecord(users);
+};
+/**
+ * ```js
+ * import { getUsers } from '@amityco/ts-sdk'
+ * const users = getUsers.locally!(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.User} objects from cache
+ *
+ * @param userIds the IDs of the {@link Amity.User} to fetch
+ * @returns the associated collection of {@link Amity.User} objects
+ *
+ * @category User API
+ */
+getUsers.locally = (userIds) => {
+    var _a;
+    const cached = (_a = pullFromCache('user', ...userIds)) !== null && _a !== void 0 ? _a : [];
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) === userIds.length)
+        return toRecord(cached);
+};
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+/**
+ * ```js
+ * import { queryUsers } from '@amityco/ts-sdk'
+ * const { users, previous, next } = await queryUsers({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.User} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.User} objects
+ *
+ * @category User API
+ * @async
+ */
+const queryUsers = async (query) => {
+    const client = getActiveClient();
+    client.log('user/queryUsers', query);
+    const _a = query !== null && query !== void 0 ? query : {}, { page, displayName, filter = 'all', sortBy = 'displayName' } = _a, params = __rest(_a, ["page", "displayName", "filter", "sortBy"]);
+    // API-FIX: parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/users`, { params: Object.assign(Object.assign({}, params), { keyword: displayName, filter,
+            sortBy, options: {
+                token: toToken(page, 'skiplimit'),
+            } }) });
+    // unpacking
+    const { paging } = data, response = __rest(data, ["paging"]);
+    decoratePayload(response);
+    ingestInCache(response);
+    const prevPage = toPage(paging.previous);
+    const nextPage = toPage(paging.next);
+    const { users } = response;
+    return { data: toRecord(users), prevPage, nextPage };
+};
+/**
+ * ```js
+ * import { queryUsers } from '@amityco/ts-sdk'
+ * const users = queryUsers.locally({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.User} objects from cache
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.User} objects
+ *
+ * @category User API
+ */
+queryUsers.locally = (query) => {
+    const client = getActiveClient();
+    client.log('user/queryUsers.locally', query);
+    // TODO
+};
+
+/**
+ * ```js
+ * import { updateUser } from '@amityco/ts-sdk'
+ * const updated = await updateUser(userId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.User}
+ *
+ * @param userId The ID of the {@link Amity.User} to update
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.User} object
+ *
+ * @category User API
+ * @async
+ */
+const updateUser = async (userId, patch) => {
+    const client = getActiveClient();
+    client.log('user/updateUser', userId, patch);
+    // API-FIX: Endpoint is malformed, userId should be a url param.
+    /*
+      const { data } = await client.http.put<Amity.Response<UserPayload>>(
+        `/api/v3/users/${userId}`, patch,
+      )
+    */
+    const { data } = await client.http.put(`/api/v3/users/`, Object.assign(Object.assign({ userId }, patch), { createNewUserWhenNotFound: false }));
+    decoratePayload(data);
+    ingestInCache(data);
+    // no need for event, fired by server
+    return data.users.find(user => user.userId === userId);
+};
+
+/**
+ * ```js
+ * import { onUserUpdated } from '@amityco/ts-sdk'
+ * const dispose = onUserUpdated(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} have 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);
+};
+
+/**
+ * ```js
+ * import { observeUser } from '@amityco/ts-sdk'
+ *
+ * let user = {}
+ * const dispose = observeUser(userId, updated => user = updated)
+ * ```
+ *
+ * @param userId the ID of the user to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the user
+ *
+ * Observe all mutation on a given {@link Amity.User}
+ * @category User Observer
+ */
+const observeUser = (userId, callback) => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    log(`observeUser(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.userId) !== userId)
+            return;
+        if (callback instanceof Function)
+            return callback(result);
+        if (action !== 'onFetch')
+            (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, result);
+        (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
+    };
+    const disposers = [];
+    disposers.push(onUserUpdated(data => router({ data }, 'onUpdate')));
+    runQuery(createQuery(getUser, userId), (result) => result.data && router(result, 'onFetch'));
+    return () => {
+        log(`observeUser(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { getFile } from '@amityco/ts-sdk'
+ * const file = await getFile('foo')
+ * ```
+ *
+ * Fetches a {@link Amity.File} object
+ *
+ * @param filelId the ID of the {@link Amity.File} to fetch
+ * @returns the associated {@link Amity.File} object
+ *
+ * @category File API
+ * @async
+ */
+const getFile = async (fileId) => {
+    const client = getActiveClient();
+    client.log('file/getFile', fileId);
+    const { data } = await client.http.get(`/api/v3/files/${fileId}`);
+    // API-FIX: backend bad serializer issue. it should be:
+    // const { files } = data
+    decorateModel(data);
+    ingestInCache({ files: [data] });
+    return data;
+};
+/**
+ * ```js
+ * import { getFile } from '@amityco/ts-sdk'
+ * const file = getFile.locally('foo')
+ * ```
+ *
+ * Fetches a {@link Amity.File} object from cache
+ *
+ * @param fileId the ID of the {@link Amity.File} to fetch
+ * @returns the associated {@link Amity.File} object
+ *
+ * @category File API
+ */
+getFile.locally = (fileId) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('file/getFile.locally', fileId);
+    const [file] = (_a = pullFromCache('file', fileId)) !== null && _a !== void 0 ? _a : [];
+    return file;
+};
+
+/**
+ * ```js
+ * import { createFile } from '@amityco/ts-sdk'
+ * const created = await createFile(formData)
+ * ```
+ *
+ * Creates an {@link Amity.File}
+ *
+ * @param formData The data necessary to create a new {@link Amity.File}
+ * @returns The newly created {@link Amity.File}
+ *
+ * @category File API
+ * @async
+ */
+const createFile = async (formData, onProgress) => {
+    const client = getActiveClient();
+    client.log('file/createFile', formData);
+    if (!formData.getAll('file').length)
+        throw new Error('The formData object must have a `file` key.');
+    const headers = 'getHeaders' in formData
+        ? formData.getHeaders()
+        : { 'content-type': 'multipart/form-data' };
+    const { data } = await client.http.post('/api/v3/files', formData, {
+        headers, onUploadProgress({ loaded, total }) {
+            onProgress && onProgress(Math.round((loaded * 100) / total));
+        }
+    });
+    // API-FIX: payload should be serialized properly
+    // const { files } = data
+    decorateModels(data);
+    ingestInCache({ files: data });
+    return data[0];
+};
+// TODO: consider doing local creation with URL.createObjectURL()
+
+/**
+ * ```js
+ * import { deleteFile } from '@amityco/ts-sdk'
+ * const success = await deleteFile('foo')
+ * ```
+ *
+ * Deletes a {@link Amity.File}
+ *
+ * @param fileId The {@link Amity.File} ID to delete
+ * @return A success boolean if the {@link Amity.File} was deleted
+ *
+ * @category File API
+ * @async
+ */
+const deleteFile = async (fileId) => {
+    const client = getActiveClient();
+    client.log('file/deleteFile', fileId);
+    const { data } = await client.http.delete(`/api/v3/files/${fileId}`);
+    const { success } = data;
+    if (success)
+        mergeInCache('file', { fileId, isDeleted: true });
+    return success;
+};
+
+/**
+ * Allow to query a file url with a selected size
+ *
+ * @param fileUrl the file Url to decorate
+ * @param size one of the selected sizes
+ * @returns the computed url for the selected size
+ */
+const fileUrlWithSize = (fileUrl, size) => {
+    return `${fileUrl}?size=${size}`;
+};
+
+/**
+ * ```js
+ * import { observeFile } from '@amityco/ts-sdk'
+ *
+ * let file = {}
+ * const dispose = observeFile(fileId, updated => file = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.File}
+ *
+ * @param fileId the ID of the file to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the file
+ *
+ * @category File Observer
+ */
+const observeFile = (fileId, callback) => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    log(`observeFile(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.fileId) !== fileId)
+            return;
+        if (callback instanceof Function)
+            return callback(result);
+        if (action !== 'onFetch')
+            (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, result);
+        (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
+    };
+    runQuery(createQuery(getFile, fileId), (result) => result.data && router(result, 'onFetch'));
+    return () => {
+        log(`observeFile(tmpid: ${timestamp}) > dispose`);
+    };
+};
+
+/**
+ * ```js
+ * import { queryRoles } from '@amityco/ts-sdk'
+ * const roles = await queryRoles()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Role} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Role} objects
+ *
+ * @category Role API
+ * @async
+ */
+const queryRoles = async (query) => {
+    const client = getActiveClient();
+    client.log('role/queryRoles', query);
+    const _a = query !== null && query !== void 0 ? query : {}, { page, displayName, sortBy } = _a, params = __rest(_a, ["page", "displayName", "sortBy"]);
+    // API-FIX: parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/roles`, {
+        params: Object.assign(Object.assign({}, params), { keyword: displayName, sortBy, options: {
+                token: toToken(page, 'skiplimit'),
+            } }),
+    });
+    // unpacking
+    const { paging } = data, response = __rest(data, ["paging"]);
+    decoratePayload(response);
+    ingestInCache(response);
+    const prevPage = toPage(paging.previous);
+    const nextPage = toPage(paging.next);
+    const { roles } = response;
+    return { data: toRecord(roles), prevPage, nextPage };
+};
+/**
+ * ```js
+ * import { queryRoles } from '@amityco/ts-sdk'
+ * const roles = queryRoles.locally({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Role} objects from cache
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Role} objects
+ *
+ * @category Role API
+ */
+queryRoles.locally = (query) => {
+    const client = getActiveClient();
+    client.log('role/queryRoles.locally', query);
+    // TODO
+};
+
+/**
+ * ```js
+ * import { getRole } from '@amityco/ts-sdk'
+ * const role = await getRole('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Role} object
+ *
+ * @param roleId the ID of the {@link Amity.Role} to fetch
+ * @returns the associated {@link Amity.Role} object
+ *
+ * @category Role API
+ * @async
+ */
+const getRole = async (roleId) => {
+    const client = getActiveClient();
+    client.log('role/getRole', roleId);
+    const { data } = await client.http.get(`/api/v3/roles/${roleId}`);
+    decorateModels(data);
+    ingestInCache({ roles: data });
+    return data.find(role => role.roleId === roleId);
+};
+/**
+ * ```js
+ * import { getRole } from '@amityco/ts-sdk'
+ * const role = getRole.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Role} object from cache
+ *
+ * @param roleId the ID of the {@link Amity.Role} to fetch
+ * @returns the associated {@link Amity.Role} object
+ *
+ * @category Role API
+ */
+getRole.locally = (roleId) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('role/getRole.locally', roleId);
+    const [role] = (_a = pullFromCache('role', roleId)) !== null && _a !== void 0 ? _a : [];
+    return role;
+};
+
+/** @hidden */
+const dispatchReactable = (referenceType, model) => {
+    if (referenceType === 'message')
+        // @ts-ignore: refactor later
+        fireEvent('v3.message.didUpdate', { messages: [model] });
+    else if (referenceType === 'post')
+        // @ts-ignore: refactor later
+        fireEvent('v3.post.didUpdate', { posts: [model] });
+    else if (referenceType === 'comment')
+        // @ts-ignore: refactor later
+        fireEvent('v3.comment.didUpdate', { comments: [model] });
+};
+
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk'
+ * const message = await getMessage('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Message} object
+ *
+ * @param messageId the ID of the {@link Amity.Message} to fetch
+ * @returns the associated {@link Amity.Message} object
+ *
+ * @category Message API
+ * @async
+ */
+const getMessage = async (messageId) => {
+    const client = getActiveClient();
+    client.log('message/getMessage', messageId);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/messages/${messageId}`);
+    decoratePayload(data);
+    ingestInCache(data);
+    const { messages } = data;
+    return messages.find(message => message.messageId === messageId);
+};
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk'
+ * const message = getMessage.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Message} object
+ *
+ * @param messageId the ID of the {@link Amity.Message} to fetch
+ * @returns the associated {@link Amity.Message} object
+ *
+ * @category Message API
+ */
+getMessage.locally = (messageId) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('message/getMessage.locally', messageId);
+    const [message] = (_a = pullFromCache('message', messageId)) !== null && _a !== void 0 ? _a : [];
+    return message;
+};
+
+/**
+ * ```js
+ * import { getMessages } from '@amityco/ts-sdk'
+ * const messages = await getMessages(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Message} objects
+ *
+ * @param messageIds the IDs of the {@link Amity.Message} to fetch
+ * @returns the associated collection of {@link Amity.Message} objects
+ *
+ * @category Message API
+ * @async
+ */
+const getMessages = async (messageIds) => {
+    const client = getActiveClient();
+    client.log('message/getMessages', messageIds);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/messages/list`, { params: { messageIds } });
+    decoratePayload(data);
+    ingestInCache(data);
+    const { messages } = data;
+    return toRecord(messages);
+};
+/**
+ * ```js
+ * import { getMessages } from '@amityco/ts-sdk'
+ * const messages = getMessages.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Message} objects from cache
+ *
+ * @param messageIds the IDs of the {@link Amity.Message} to fetch
+ * @returns the associated collection of {@link Amity.Message} objects
+ *
+ * @category Message API
+ */
+getMessages.locally = (messageIds) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('message/getMessages.locally', messageIds);
+    const cached = (_a = pullFromCache('message', ...messageIds)) !== null && _a !== void 0 ? _a : [];
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) === messageIds.length)
+        return toRecord(cached);
+};
+
+/**
+ * ```js
+ * import { queryMessages } from '@amityco/ts-sdk'
+ * const messages = await queryMessages({ channelId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Message} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Message} objects
+ *
+ * @category Message API
+ * @async
+ */
+const queryMessages = async (query) => {
+    const client = getActiveClient();
+    client.log('message/queryMessages', query);
+    const _a = query !== null && query !== void 0 ? query : {}, { page } = _a, params = __rest(_a, ["page"]);
+    // API-FIX: parameters should be querystring. (1)
+    // API-FIX: backend should answer Amity.Response (2)
+    // API-FIX: pagination should not be indexed on channelSegment (3)
+    // const { data } = await client.http.get<Amity.Response<Amity.Paged<Amity.MessagePayload>>>(
+    const { data } = await client.http.get(`/api/v3/messages`, { params: Object.assign(Object.assign({}, params), { options: {
+                token: toToken(page, 'afterbefore'),
+            } }), });
+    // API-FIX: backend should answer Amity.Response (2)
+    // const { paging, messages } = unwrapPayload(data)
+    const { paging } = data, response = __rest(data, ["paging"]);
+    decoratePayload(response);
+    ingestInCache(response);
+    const { messages } = response;
+    const nextPage = toPage(paging.next);
+    const prevPage = toPage(paging.previous);
+    return { data: toRecord(messages), nextPage, prevPage };
+};
+/**
+ * ```js
+ * import { queryMessages } from '@amityco/ts-sdk'
+ * const messages = queryMessages.locally!({ channelId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Message} objects from cache
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Message} objects
+ *
+ * @category Message API
+ */
+queryMessages.locally = (query) => {
+    var _a, _b, _c, _d, _e;
+    const client = getActiveClient();
+    client.log('message/queryMessages.locally', query);
+    const { channelId, page } = query;
+    const [channel] = (_a = pullFromCache('channel', channelId)) !== null && _a !== void 0 ? _a : [];
+    let messages = (_b = pullFromCache('message')) !== null && _b !== void 0 ? _b : [];
+    // filter
+    messages = filterByPropEquality(messages, 'channelId', channelId);
+    // API-FIX filter by isDeleted doesn't work in backend... srsly wtf... how do they test things???
+    // messages = filterByPropEquality(messages, 'isDeleted', query?.isDeleted)
+    // sort
+    messages = messages.sort(sortByChannelSegment);
+    // paging
+    if (page) {
+        // slice
+        // API-FIX we can't reuse proper page because the message page is done
+        // by channelSegment which is sadly unique to the entire platform.
+        // this part is copied and adapted from sliceByPaging function
+        let start = 0;
+        let end = undefined;
+        // next page behavior
+        if ('after' in page) {
+            start = page.after !== 0
+                ? messages.findIndex(message => message.channelSegment === (page === null || page === void 0 ? void 0 : page.after)) + 1
+                : 0;
+            end = start + page.limit;
+            // prev page behavior
+        }
+        else if ('before' in page) {
+            end = page.before !== 0
+                ? messages.findIndex(message => message.channelSegment === (page === null || page === void 0 ? void 0 : page.before)) + 1
+                : messages.length - 1;
+            start = end > page.limit ? end - page.limit : 0;
+        }
+        const paged = messages.slice(start, end);
+        messages = paged.length === page.limit ? paged : [];
+    }
+    const prevPage = ((_c = messages[0]) === null || _c === void 0 ? void 0 : _c.channelSegment) > 0
+        ? { before: messages[0].channelSegment, limit: page === null || page === void 0 ? void 0 : page.limit }
+        : undefined;
+    const nextPage = ((_d = messages[messages.length - 1]) === null || _d === void 0 ? void 0 : _d.channelSegment) < ((_e = channel === null || channel === void 0 ? void 0 : channel.messageCount) !== null && _e !== void 0 ? _e : 0)
+        ? { after: messages[messages.length - 1].channelSegment, limit: page === null || page === void 0 ? void 0 : page.limit }
+        : undefined;
+    return { data: toRecord(messages), nextPage, prevPage };
+};
+
+/**
+ * ```js
+ * import { createMessage } from '@amityco/ts-sdk'
+ * const created = await createMessage({
+ *   channelId: 'foobar',
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Creates an {@link Amity.Message}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Message}
+ * @returns The newly created {@link Amity.Message}
+ *
+ * @category Message API
+ * @async
+ */
+const createMessage = async (bundle) => {
+    const client = getActiveClient();
+    client.log('user/createMessage', bundle);
+    const { data } = await client.http.post('/api/v3/messages', bundle);
+    decoratePayload(data);
+    ingestInCache(data);
+    // no need for event, fired by server
+    const { messages } = data;
+    return messages[0];
+};
+/**
+ * ```js
+ * import { createMessage } from '@amityco/ts-sdk'
+ * const created = createMessage.locally({
+ *   channelId: 'foobar',
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Creates an {@link Amity.Message} in cache
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Message}
+ * @returns The newly created {@link Amity.Message}
+ *
+ * @category Message API
+ */
+createMessage.optimistically = (bundle) => {
+    var _a, _b, _c;
+    const client = getActiveClient();
+    client.log('user/createMessage.locally', bundle);
+    // should we do this?
+    if (!client.cache)
+        return;
+    const [channel] = (_a = pullFromCache('channel', bundle.channelId)) !== null && _a !== void 0 ? _a : [];
+    pushToCache('channel', Object.assign(Object.assign({}, channel), { messageCount: ((_b = channel.messageCount) !== null && _b !== void 0 ? _b : 0) + 1 }));
+    const message = Object.assign(Object.assign({ localId: uuid(), messageId: Math.random().toString(16), userId: client.userId, channelSegment: ((_c = channel === null || channel === void 0 ? void 0 : channel.messageCount) !== null && _c !== void 0 ? _c : 0) + 1, createdAt: new Date().toISOString() }, bundle), { syncedAt: -1 });
+    pushToCache('message', message);
+    fireEvent('v3.message.didCreate', { messages: [message] });
+    return message;
+};
+
+/**
+ * ```js
+ * import { updateMessage } from '@amityco/ts-sdk'
+ * const updated = await updateMessage(messageId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message}
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ * @async
+ */
+const updateMessage = async (messageId, patch) => {
+    const client = getActiveClient();
+    client.log('user/updateMessage', patch);
+    const { data } = await client.http.put(`/api/v3/messages/${messageId}`, patch);
+    decoratePayload(data);
+    ingestInCache(data);
+    // no need for event, fired by server
+    return data.messages.find(message => message.messageId === messageId);
+};
+/**
+ * ```js
+ * import { updateMessage } from '@amityco/ts-sdk'
+ * const updated = updateMessage.locally('foobar', {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message} in cache
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ */
+updateMessage.optimistically = (messageId, patch) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('user/updateMessage', patch);
+    const [message] = (_a = pullFromCache('message', messageId)) !== null && _a !== void 0 ? _a : [];
+    if (!message)
+        return;
+    const updated = Object.assign(Object.assign(Object.assign({}, message), patch), { updatedAt: new Date().toISOString() });
+    pushToCache('message', updated);
+    fireEvent('v3.message.didUpdate', { messages: [updated] });
+    return updated;
+};
+
+/**
+ * ```js
+ * import { deleteMessage } from '@amityco/ts-sdk'
+ * const success = await deleteMessage('foobar')
+ * ```
+ *
+ * Delete a {@link Amity.Message}
+ *
+ * @param The ID of the {@link Amity.Message} to delete
+ * @return A success boolean if the {@link Amity.Message} was deleted
+ *
+ * @category Message API
+ * @async
+ */
+const deleteMessage = async (messageId) => {
+    const client = getActiveClient();
+    client.log('message/deleteMessage', messageId);
+    // API-FIX: This endpoint has not been implemented yet.
+    await client.http.delete(`/api/v3/messages/${messageId}`);
+    const deleted = await getMessage(messageId);
+    // no need for event, fired by server
+    return deleted;
+};
+/**
+ * ```js
+ * import { deleteMessage } from '@amityco/ts-sdk'
+ * const success = deleteMessage.locally('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Message}
+ *
+ * @param messageId The {@link Amity.Message} ID to delete
+ * @return A success boolean if the {@link Amity.Message} was deleted
+ *
+ * @category Message API
+ */
+deleteMessage.optimistically = (messageId) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('message/deleteMessage', messageId);
+    const [message] = (_a = pullFromCache('message', messageId)) !== null && _a !== void 0 ? _a : [];
+    if (!message)
+        return;
+    const deleted = Object.assign(Object.assign({}, message), { isDeleted: true, updatedAt: new Date().toISOString() });
+    pushToCache('message', deleted);
+    fireEvent('v3.message.didDelete', { messages: [deleted] });
+    return deleted;
+};
+
+/**
+ * ```js
+ * import { queryPosts } from '@amityco/ts-sdk'
+ * const posts = await queryPosts({ targetId, targetType })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects
+ *
+ * @param query The query parameters
+ * @returns posts
+ *
+ * @category Post API
+ * @async
+ */
+const queryPosts = async (query) => {
+    const client = getActiveClient();
+    client.log('post/queryPosts', query);
+    const _a = query !== null && query !== void 0 ? query : {}, { page } = _a, params = __rest(_a, ["page"]);
+    // API-FIX: parameters should be querystring. (1)
+    // API-FIX: backend should answer Amity.Response (2)
+    // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<Amity.PostPayload>>>(
+    const { data } = await client.http.get(`/api/v3/posts`, { params: Object.assign(Object.assign({}, params), { options: {
+                token: toToken(page, 'skiplimit'),
+            } }), });
+    // API-FIX: backend should answer Amity.Response (2)
+    // const { paging, posts } = unwrapPayload(data)
+    const { paging } = data, response = __rest(data, ["paging"]);
+    decoratePayload(response);
+    ingestInCache(response);
+    const { posts } = response;
+    const nextPage = toPage(paging.next);
+    const prevPage = toPage(paging.previous);
+    return { data: toRecord(posts), nextPage, prevPage };
+};
+/**
+ * ```js
+ * import { queryPosts } from '@amityco/ts-sdk'
+ * const posts = queryPosts.locally({ targetId, targetType })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns posts
+ *
+ * @category Post API
+ */
+queryPosts.locally = (query) => {
+    const client = getActiveClient();
+    client.log('post/queryPosts.locally', query);
+    // TODO
+};
+
+/**
+ * ```js
+ * import { getPosts } from '@amityco/ts-sdk'
+ * const posts = await getPosts(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Post} objects
+ *
+ * @param postIds the IDs of the {@link Amity.Post} to fetch
+ * @returns the associated collection of {@link Amity.Post} objects
+ *
+ * @category Post API
+ * @async
+ */
+const getPosts = async (postIds) => {
+    const client = getActiveClient();
+    client.log('post/getPosts', postIds);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/posts/list`, { params: { postIds } });
+    decoratePayload(data);
+    ingestInCache(data);
+    const { posts } = data;
+    return posts;
+};
+/**
+ * ```js
+ * import { getPosts } from '@amityco/ts-sdk'
+ * const posts = getPosts.locally(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Post} objects from cache
+ *
+ * @param postIds the IDs of the {@link Amity.Post} to fetch
+ * @returns the associated collection of {@link Amity.Post} objects
+ *
+ * @category Post API
+ */
+getPosts.locally = (postIds) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('post/getPosts.locally', postIds);
+    const cached = (_a = pullFromCache('post', ...postIds)) !== null && _a !== void 0 ? _a : [];
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) === postIds.length)
+        return toRecord(cached);
+};
+
+/**
+ * ```js
+ * import { getPost } from '@amityco/ts-sdk'
+ * const post = await getPost('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Post} object
+ *
+ * @param postId the ID of the {@link Amity.Post} to fetch
+ * @returns the associated {@link Amity.Post} object
+ *
+ * @category Post API
+ * @async
+ */
+const getPost = async (postId) => {
+    const client = getActiveClient();
+    client.log('post/getPost', postId);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/posts/${postId}`);
+    decoratePayload(data);
+    ingestInCache(data);
+    const { posts } = data;
+    return posts.find(post => post.postId === postId);
+};
+/**
+ * ```js
+ * import { getPost } from '@amityco/ts-sdk'
+ * const post = getPost.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Post} object
+ *
+ * @param postId the ID of the {@link Amity.Post} to fetch
+ * @returns the associated {@link Amity.Post} object
+ *
+ * @category Post API
+ */
+getPost.locally = (postId) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('post/getPost.locally', postId);
+    const [post] = (_a = pullFromCache('post', postId)) !== null && _a !== void 0 ? _a : [];
+    return post;
+};
+
+/**
+ * ```js
+ * import { createPost } from '@amityco/ts-sdk'
+ * const newPost = await createPost(bundle)
+ * ```
+ *
+ * Creates an {@link Amity.Post}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Post}
+ * @returns The newly created {@link Amity.Post}
+ *
+ * @category Post API
+ * @async
+ */
+const createPost = async (bundle) => {
+    const client = getActiveClient();
+    client.log('post/createPost', bundle);
+    // API-FIX: backend rejects that we pass the dataType manually T_T
+    if (!bundle.dataType || ['text', 'image', 'file'].includes(bundle.dataType))
+        delete bundle.dataType;
+    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);
+    const { posts } = data;
+    return posts[0];
+};
+
+/**
+ * ```js
+ * import { updatePost } from '@amityco/ts-sdk'
+ * const updated = await updatePost(postId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Post}
+ *
+ * @param postId The ID of the {@link Amity.Post} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Post} object
+ *
+ * @category Post API
+ * @async
+ */
+const updatePost = async (postId, patch) => {
+    const client = getActiveClient();
+    client.log('user/updatePost', patch);
+    const { data } = await client.http.put(`/api/v3/posts/${postId}`, patch);
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent('v3.post.didUpdate', data);
+    const { posts } = data;
+    return posts.find(post => post.postId === postId);
+};
+
+/**
+ * ```js
+ * import { queryCommunities } from '@amityco/ts-sdk'
+ * const communities = await queryCommunities()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Community} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Community} objects
+ *
+ * @category Community API
+ * @async
+ */
+const queryCommunities = async (query) => {
+    const client = getActiveClient();
+    client.log('channel/queryCommunities', query);
+    // safe decapsulation
+    const _a = query !== null && query !== void 0 ? query : {}, { page, displayName, membership } = _a, params = __rest(_a, ["page", "displayName", "membership"]);
+    // API-FIX: parameters should be querystring.
+    // API-FIX: backend doesnt answer Amity.Response
+    // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<CommunityPayload>>>(
+    const { data } = await client.http.get(`/api/v3/communities`, { params: Object.assign(Object.assign({}, params), { keyword: displayName, filter: membership, options: {
+                token: toToken(page, 'skiplimit')
+            } }) });
+    // API-FIX: backend to response Amity.Response: const { paging, communities } = unwrapPayload(data)
+    const { paging } = data, response = __rest(data, ["paging"]);
+    decoratePayload(response);
+    ingestInCache(response);
+    const prevPage = toPage(paging === null || paging === void 0 ? void 0 : paging.previous);
+    const nextPage = toPage(paging === null || paging === void 0 ? void 0 : paging.next);
+    const { communities } = response;
+    return { data: toRecord(communities), prevPage, nextPage };
+};
+/**
+ * ```js
+ * import { queryCommunities } from '@amityco/ts-sdk'
+ * const communities = queryCommunities.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Community} objects from cache
+ *
+ * @param query The query parameters
+ * @returns communities
+ *
+ * @category Community API
+ */
+queryCommunities.locally = (query) => {
+    const client = getActiveClient();
+    client.log('community/queryCommunities.locally', query);
+    // TODO
+};
+
+/**
+ * ```js
+ * import { getCommunities } from '@amityco/ts-sdk'
+ * const communities = await getCommunities(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Community} objects
+ *
+ * @param communityIds the IDs of the {@link Amity.Community} to fetch
+ * @returns the associated collection of {@link Amity.Community} objects
+ *
+ * @category Community API
+ * @async
+ */
+const getCommunities = async (communityIds) => {
+    const client = getActiveClient();
+    client.log('community/getCommunities', communityIds);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/communities/list`, { params: { communityIds } });
+    decoratePayload(data);
+    ingestInCache(data);
+    const { communities } = data;
+    return toRecord(communities);
+};
+/**
+ * ```js
+ * import { getCommunities } from '@amityco/ts-sdk'
+ * const communities = getCommunities.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Community} objects from cache
+ *
+ * @param communityIds the IDs of the {@link Amity.Community} to fetch
+ * @returns the associated collection of {@link Amity.Community} objects
+ *
+ * @category Community API
+ */
+getCommunities.locally = (communityIds) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('community/getCommunities.locally', communityIds);
+    const cached = (_a = pullFromCache('community', ...communityIds)) !== null && _a !== void 0 ? _a : [];
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) === communityIds.length)
+        return toRecord(cached);
+};
+
+/**
+ * ```js
+ * import { getCommunity } from '@amityco/ts-sdk'
+ * const community = await getCommunity('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Community} object
+ *
+ * @param communityId the ID of the {@link Amity.Community} to fetch
+ * @returns the associated {@link Amity.Community} object
+ *
+ * @category Community API
+ * @async
+ */
+const getCommunity = async (communityId) => {
+    const client = getActiveClient();
+    client.log('community/getCommunity', communityId);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/communities/${communityId}`);
+    decoratePayload(data);
+    ingestInCache(data);
+    const { communities } = data;
+    return communities.find(community => community.communityId === communityId);
+};
+/**
+ * ```js
+ * import { getCommunity } from '@amityco/ts-sdk'
+ * const community = getCommunity.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Community} object from cache
+ *
+ * @param communityId the ID of the {@link Amity.Community} to fetch
+ * @returns the associated {@link Amity.Community} object
+ *
+ * @category Community API
+ */
+getCommunity.locally = (communityId) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('community/getCommunity.locally', communityId);
+    const [community] = (_a = pullFromCache('community', communityId)) !== null && _a !== void 0 ? _a : [];
+    return community;
+};
+
+/**
+ * ```js
+ * import { createCommunity } from '@amityco/ts-sdk'
+ * const created = await createCommunity({ communityId: 'foobar', displayName: 'foobar' })
+ * ```
+ *
+ * Creates an {@link Amity.Community}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Community}
+ * @returns The newly created {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+const createCommunity = async (bundle) => {
+    const client = getActiveClient();
+    client.log('user/createCommunity', bundle);
+    const { data } = await client.http.post('/api/v3/communities/', bundle);
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent('v3.community.didCreate', data);
+    const { communities } = data;
+    return communities[0];
+};
+
+/**
+ * ```js
+ * import { updateCommunity } from '@amityco/ts-sdk'
+ * const updated = await updateCommunity(communityId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Community} object
+ *
+ * @category Community API
+ * @async
+ */
+const updateCommunity = async (communityId, patch) => {
+    const client = getActiveClient();
+    client.log('community/updateCommunity', communityId, patch);
+    const { data } = await client.http.put(`/api/v3/communities/${communityId}`, patch);
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent('v3.community.didUpdate', data);
+    const { communities } = data;
+    return communities.find(community => community.communityId === communityId);
+};
+
+/**
+ * ```js
+ * import { deleteCommunity } from '@amityco/ts-sdk'
+ * const success = await deleteCommunity('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Community}
+ *
+ * @param communityId The {@link Amity.Community} ID to delete
+ * @return A success boolean if the {@link Amity.Community} was deleted
+ *
+ * @category Community API
+ * @async
+ */
+const deleteCommunity = async (communityId) => {
+    const client = getActiveClient();
+    client.log('community/deleteCommunity', 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] });
+    return deleted;
+};
+
+/**
+ * ```js
+ * import { joinCommunity } from '@amityco/ts-sdk'
+ * const isJoined = await joinCommunity('foobar')
+ * ```
+ *
+ * Joins a {@link Amity.Community} object
+ *
+ * @param communityId the {@link Amity.Community} to join
+ * @returns A success boolean if the {@link Amity.Community} was joined
+ *
+ * @category Community API
+ * @async
+ */
+const joinCommunity = async (communityId) => {
+    const client = getActiveClient();
+    client.log('community/joinCommunity', communityId);
+    const { data } = await client.http.post(`/api/v3/communities/${communityId}/join`);
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent('v3.community.didJoin', {
+        communities: data.communities
+    });
+    const { communityUsers } = data;
+    return !!communityUsers.find(communityUser => (communityUser.communityId === communityId
+        && communityUser.communityMembership === 'member'));
+};
+
+/**
+ * ```js
+ * import { leaveCommunity } from '@amityco/ts-sdk'
+ * const isLeft = await leaveCommunity('foobar')
+ * ```
+ *
+ * Leaves a {@link Amity.Community} object
+ *
+ * @param communityId the {@link Amity.Community} to leave
+ * @returns A success boolean if {@link Amity.Community} was left
+ *
+ * @category Community API
+ * @async
+ */
+const leaveCommunity = async (communityId) => {
+    const client = getActiveClient();
+    client.log('community/leaveCommunity', communityId);
+    const { data } = await client.http.delete(`/api/v3/communities/${communityId}/leave`);
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent('v3.community.didJoin', {
+        communities: data.communities,
+    });
+    const { communityUsers } = data;
+    return !!communityUsers.find(communityUser => (communityUser.communityId === communityId
+        && communityUser.communityMembership !== 'member'));
+};
+
+/**
+ * ```js
+ * import { queryCommunityMembers } from '@amityco/ts-sdk'
+ * const communityMembers = await queryCommunityMembers({ communityId: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.CommunityUser} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.CommunityUser} objects
+ *
+ * @category Community API
+ * @async
+ **/
+const queryCommunityMembers = async (query) => {
+    const client = getActiveClient();
+    client.log('community/queryCommunityMembers', query);
+    const _a = query !== null && query !== void 0 ? query : {}, { page, communityId } = _a, params = __rest(_a, ["page", "communityId"]);
+    const { data } = await client.http.get(`/api/v3/communities/${communityId}/users`, {
+        params: Object.assign(Object.assign({}, params), { options: {
+                token: toToken(page, 'skiplimit'),
+            } }),
+    });
+    const { paging } = data, response = __rest(data, ["paging"]);
+    decoratePayload(response);
+    ingestInCache(response);
+    const { communityUsers } = response;
+    const nextPage = toPage(paging.next);
+    const prevPage = toPage(paging.previous);
+    return { data: toRecord(communityUsers), nextPage, prevPage };
+};
+/**
+ * ```js
+ * import { queryCommunityMembers } from '@amityco/ts-sdk'
+ * const communityMembers = await queryCommunityMembers(query)
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns posts
+ *
+ * @category Post API
+ */
+queryCommunityMembers.locally = (query) => {
+    const client = getActiveClient();
+    client.log('community/queryCommunityMembers', query);
+    // TODO
+};
+
+/**
+ * ```js
+ * import { addCommunityMembers } from '@amityco/ts-sdk'
+ * const updated = await addCommunityMembers(communityId, ['foo', 'bar'])
+ * ```
+ *
+ * Adds a list of {@link Amity.User} to a {@link Amity.Community} to add users to
+ *
+ * @param communityId The ID of the {@link Amity.Community} to perform
+ * @param userIds The list of IDs {@link Amity.User} to add
+ * @returns A success boolean if the {@link Amity.User} were added to the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+const addCommunityMembers = async (communityId, userIds) => {
+    const client = getActiveClient();
+    client.log('community/addCommunityMembers', communityId, userIds);
+    const { data } = await client.http.post(`/api/v3/communities/${communityId}/users`, { communityId, userIds });
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent('v3.community.didAddUsers', {
+        communities: data.communities,
+    });
+    const { communityUsers } = data;
+    return !!communityUsers.find(communityUser => communityUser.communityId === communityId &&
+        communityUser.communityMembership === 'member');
+};
+
+/**
+ * ```js
+ * import { removeCommunityMembers } from '@amityco/ts-sdk'
+ * const updated = await removeCommunityMembers(communityId, ['foo', 'bar'])
+ * ```
+ *
+ * Removes a list of {@link Amity.User} from a {@link Amity.Channel}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to edit
+ * @param userIds The list of IDs {@link Amity.User} to remove
+ * @returns A success boolean if the list of {@link Amity.User} were removed from the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+const removeCommunityMembers = async (communityId, userIds) => {
+    const client = getActiveClient();
+    client.log('community/removeCommunityMembers', communityId, userIds);
+    const { data } = await client.http.delete(`/api/v3/communities/${communityId}/users`, { data: { communityId, userIds } });
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent('v3.community.didRemoveUsers', {
+        communities: data.communities,
+    });
+    const { communityUsers } = data;
+    return !!communityUsers.find(communityUser => communityUser.communityId === communityId &&
+        communityUser.communityMembership !== 'member');
+};
+
+/**
+ * ```js
+ * import { addCommunityMembersRole } from '@amityco/ts-sdk'
+ * const updated = await addCommunityMembersRole(communityId, 'foo', ['bar'])
+ * ```
+ *
+ * Adds an {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to perform
+ * @param roleId The ID of the {@link Amity.Role} to apply
+ * @param userId Array of IDs of the {@link Amity.User} to perform
+ * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.User} in the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+const addCommunityMembersRole = async (communityId, roleId, userIds) => {
+    const client = getActiveClient();
+    client.log('community/addCommunityMembersRole', communityId, roleId, userIds);
+    const { data } = await client.http.post(`/api/v3/communities/${communityId}/users/roles`, { communityId, role: roleId, userIds });
+    decoratePayload(data);
+    ingestInCache(data);
+    const { communityUsers } = data;
+    return !!communityUsers.find(communityUser => communityUser.communityId === communityId && communityUser.roles.includes(roleId));
+};
+
+/**
+ * ```js
+ * import { removeCommunityMembersRole } from '@amityco/ts-sdk'
+ * const updated = await removeCommunityMembersRole(communityId,  'foo', ['bar'])
+ * ```
+ *
+ * Removes an {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to perform
+ * @param role The ID of the {@link Amity.Role} to apply
+ * @param userId Array of IDs of the {@link Amity.User} to perform
+ * @returns A success boolean if the {@link Amity.Role} were removed from list of {@link Amity.User} in the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+const removeCommunityMembersRole = async (communityId, roleId, userIds) => {
+    const client = getActiveClient();
+    client.log('community/removeCommunityMembersRole', communityId, roleId, userIds);
+    const { data } = await client.http.delete(`/api/v3/communities/${communityId}/users/roles`, { data: { communityId, role: roleId, userIds } });
+    decoratePayload(data);
+    ingestInCache(data);
+    const { communityUsers } = data;
+    return !!communityUsers.find(communityUser => communityUser.communityId === communityId && !communityUser.roles.includes(roleId));
+};
+
+/**
+ * ```js
+ * import { deletePost } from '@amityco/ts-sdk'
+ * const success = await deletePost('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
+ *
+ * @category Post API
+ * @async
+ */
+const deletePost = async (postId) => {
+    const client = getActiveClient();
+    client.log('post/deletePost', postId);
+    // API-FIX: This endpoint has not been implemented yet.
+    await client.http.delete(`/api/v3/posts/${postId}`);
+    // API-FIX: as for now we have no choice but to refetch
+    const deleted = await getPost(postId);
+    if (deleted.targetType === 'community') {
+        const community = await getCommunity(deleted.targetId);
+        fireEvent('v3.community.didUpdate', { communities: [community] });
+    }
+    fireEvent('v3.post.didDelete', { posts: [deleted] });
+    return deleted;
+};
+
+/**
+ * ```js
+ * import { queryComments } from '@amityco/ts-sdk'
+ * const comments = await queryComments({ postId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Comment} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Comment} objects
+ *
+ * @category Comment API
+ * @async
+ */
+const queryComments = async (query) => {
+    const client = getActiveClient();
+    client.log('comment/queryComments', query);
+    const { page } = query, params = __rest(query, ["page"]);
+    query.parentId !== undefined;
+    // API-FIX: parameters should be querystring. (1)
+    // API-FIX: backend should answer Amity.Response (2)
+    // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<Amity.CommentPayload>>>(
+    const { data } = await client.http.get(`/api/v3/comments`, {
+        params: Object.assign(Object.assign({}, params), { 
+            //      filterByParentId, API-FIX: backend does not support this boolean LOL. what the hell seriously.
+            options: {
+                token: toToken(page, 'afterbefore'),
+            } }),
+    });
+    // API-FIX: backend should answer Amity.Response (2)
+    // const { paging, comments } = unwrapPayload(data)
+    const { paging } = data, response = __rest(data, ["paging"]);
+    decoratePayload(response);
+    ingestInCache(response);
+    const prevPage = toPage(paging.previous);
+    const nextPage = toPage(paging.next);
+    const { comments } = response;
+    return { data: toRecord(comments), prevPage, nextPage };
+};
+/**
+ * ```js
+ * import { queryComments } from '@amityco/ts-sdk'
+ * const comments = queryComments.locally({ postId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Comment} objects from cache
+ *
+ * @param query The query parameters
+ * @returns comments
+ *
+ * @category Comment API
+ */
+queryComments.locally = (query) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('post/queryComments.locally', query);
+    const { referenceId, referenceType, parentId, isDeleted, page = { before: 0, limit: 5 }, } = query;
+    if (isNaN(page.after) && isNaN(page.before))
+        page.before = 0;
+    if (isNaN(page.limit))
+        page.limit = 5;
+    let comments = (_a = pullFromCache('comment')) !== null && _a !== void 0 ? _a : [];
+    // no cache
+    if (!comments.length)
+        return;
+    // filter
+    comments = filterByPropEquality(comments, 'referenceId', referenceId);
+    comments = filterByPropEquality(comments, 'referenceType', referenceType);
+    comments = filterByPropEquality(comments, 'parentId', parentId);
+    comments = filterByPropEquality(comments, 'isDeleted', isDeleted);
+    // no interesting cache
+    if (!comments.length)
+        return;
+    // sort
+    comments = comments.sort(sortBySegmentNumber);
+    // paging
+    // API-FIX we can't reuse proper page because the message page is done
+    // by segmentNumber which is sadly unique to the entire platform.
+    // this part is copied and adapted from sliceByPaging function
+    const afterIndex = !isNaN(page.after)
+        ? comments.findIndex(({ segmentNumber }) => segmentNumber === page.after + 1)
+        : 0;
+    const beforeIndex = !isNaN(page.before) && page.before !== 0
+        ? comments.findIndex(({ segmentNumber }) => segmentNumber === page.before - 1) + 1
+        : comments.length;
+    if (afterIndex < 0 || beforeIndex < 0)
+        return;
+    let slice = comments.slice(afterIndex !== -1 ? afterIndex : 0, beforeIndex !== -1 ? beforeIndex : undefined);
+    // nothing left after slicing
+    if (!slice.length)
+        return;
+    if (!isNaN(page.after) && !isNaN(page.before)) ;
+    else if (!isNaN(page.after)) {
+        slice = slice.slice(0, page.limit);
+    }
+    else if (!isNaN(page.before)) {
+        slice = slice.slice(-page.limit);
+    }
+    for (let i = 0; i < slice.length - 1; i++)
+        if (slice[i].segmentNumber !== slice[i + 1].segmentNumber - 1)
+            return;
+    const prevPage = slice[0].segmentNumber > 1
+        ? { before: slice[0].segmentNumber, limit: page.limit }
+        : undefined;
+    const nextPage = {
+        after: slice[slice.length - 1].segmentNumber,
+        limit: page.limit,
+    };
+    return { data: toRecord(slice), nextPage, prevPage };
+};
+
+/**
+ * ```js
+ * import { getComments } from '@amityco/ts-sdk'
+ * const comments = await getComments(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Comment} objects
+ *
+ * @param commentIds the IDs of the {@link Amity.Comment} to fetch
+ * @returns the associated collection of {@link Amity.Comment} objects
+ *
+ * @category Comment API
+ * @async
+ */
+const getComments = async (commentIds) => {
+    const client = getActiveClient();
+    client.log('comment/getComments', commentIds);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/comments/list`, { params: { commentIds } });
+    decoratePayload(data);
+    ingestInCache(data);
+    const { comments } = data;
+    return toRecord(comments);
+};
+/**
+ * ```js
+ * import { getComments } from '@amityco/ts-sdk'
+ * const comments = getComments.locally(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Comment} objects from cache
+ *
+ * @param commentIds the IDs of the {@link Amity.Comment} to fetch
+ * @returns the associated collection of {@link Amity.Comment} objects
+ *
+ * @category Comment API
+ */
+getComments.locally = (commentIds) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('comment/getComments.locally', commentIds);
+    const cached = (_a = pullFromCache('comment', ...commentIds)) !== null && _a !== void 0 ? _a : [];
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) === commentIds.length)
+        return toRecord(cached);
+};
+
+/**
+ * ```js
+ * import { getComment } from '@amityco/ts-sdk'
+ * const comment = await getComment('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Comment} object
+ *
+ * @param commentId the ID of the {@link Amity.Comment} to fetch
+ * @returns the associated {@link Amity.Comment} object
+ *
+ * @category Comment API
+ * @async
+ */
+const getComment = async (commentId) => {
+    const client = getActiveClient();
+    client.log('comment/getComment', commentId);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/comments/${commentId}`);
+    decoratePayload(data);
+    ingestInCache(data);
+    const { comments } = data;
+    return comments.find(comment => comment.commentId === commentId);
+};
+/**
+ * ```js
+ * import { getComment } from '@amityco/ts-sdk'
+ * const comment = getComment.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Comment} object
+ *
+ * @param commentId the ID of the {@link Amity.Comment} to fetch
+ * @returns the associated {@link Amity.Comment} object
+ *
+ * @category Comment API
+ */
+getComment.locally = (commentId) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('comment/getComment.locally', commentId);
+    const [comment] = (_a = pullFromCache('comment', commentId)) !== null && _a !== void 0 ? _a : [];
+    return comment;
+};
+
+/**
+ * ```js
+ * import { createComment } from '@amityco/ts-sdk'
+ * const newComment = await createComment(bundle)
+ * ```
+ *
+ * Creates an {@link Amity.Comment}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Comment}
+ * @returns The newly created {@link Amity.Comment}
+ *
+ * @category Comment API
+ * @async
+ */
+const createComment = async (bundle) => {
+    const client = getActiveClient();
+    client.log('comment/createComment', bundle);
+    const { data } = await client.http.post('/api/v3/comments', bundle);
+    decoratePayload(data);
+    ingestInCache(data);
+    const post = await getPost(bundle.referenceId);
+    fireEvent('v3.post.didUpdate', { posts: [post] });
+    fireEvent('v3.comment.didCreate', data);
+    const { comments } = data;
+    return comments[0];
+};
+
+/**
+ * ```js
+ * import { updateComment } from '@amityco/ts-sdk'
+ * const updated = await updateComment(commentId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Comment}
+ *
+ * @param commentId The ID of the {@link Amity.Comment} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Comment} object
+ *
+ * @category Comment API
+ * @async
+ */
+const updateComment = async (commentId, patch) => {
+    const client = getActiveClient();
+    client.log('user/updateComment', patch);
+    const { data } = await client.http.put(`/api/v3/comments/${commentId}`, patch);
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent('v3.comment.didUpdate', data);
+    const { comments } = data;
+    return comments.find(comment => comment.commentId === commentId);
+};
+
+/**
+ * ```js
+ * import { deleteComment } from '@amityco/ts-sdk'
+ * const success = await deleteComment('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Comment}
+ *
+ * @param commentId The {@link Amity.Comment} ID to delete
+ * @return A success boolean if the {@link Amity.Comment} was deleted
+ *
+ * @category Comment API
+ * @async
+ */
+const deleteComment = async (commentId) => {
+    const client = getActiveClient();
+    client.log('comment/deleteComment', commentId);
+    // API-FIX: This endpoint has not been implemented yet.
+    await client.http.delete(`/api/v3/comments/${commentId}`);
+    const deleted = await getComment(commentId);
+    const post = await getPost(deleted.referenceId);
+    fireEvent('v3.post.didUpdate', { posts: [post] });
+    fireEvent('v3.comment.didDelete', { comments: [deleted] });
+    return deleted;
+};
+
+/** @hidden */
+const fetchReference = async (referenceType, referenceId) => {
+    if (referenceType === 'message')
+        return getMessage(referenceId);
+    else if (referenceType === 'post')
+        return getPost(referenceId);
+    else if (referenceType === 'comment')
+        return getComment(referenceId);
+    throw new Error(`Incorrect referenceType: ${referenceType}`);
+};
+
+/**
+ * ```js
+ * import { addReaction } from '@amityco/ts-sdk'
+ * const success = await addReaction('post', postId, 'like')
+ * ```
+ *
+ * Creates an {@link Amity.Reaction}
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ * @async
+ **/
+const addReaction = async (referenceType, referenceId, reactionName) => {
+    var _a, _b;
+    const client = getActiveClient();
+    client.log('reaction/createReaction', {
+        referenceId,
+        referenceType,
+        reactionName,
+    });
+    await client.http.post('/api/v2/reactions', { referenceId, referenceType, reactionName });
+    const model = await fetchReference(referenceType, referenceId);
+    dispatchReactable(referenceType, model);
+    return (_b = (_a = model.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName)) !== null && _b !== void 0 ? _b : false;
+};
+/**
+ * ```js
+ * import { addReaction } from '@amityco/ts-sdk'
+ * const success = addReaction.optimistically('post', postId, 'like')
+ * ```
+ *
+ * Creates an {@link Amity.Reaction} optimistically
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ **/
+addReaction.optimistically = (referenceType, referenceId, reactionName) => {
+    var _a, _b;
+    const model = mutateCache(referenceType, referenceId, model => {
+        var _a, _b, _c;
+        if ((_a = model.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName))
+            return;
+        return Object.assign(Object.assign({}, model), { syncedAt: -1, reactionsCount: model.reactionsCount + 1, myReactions: [...((_b = model.myReactions) !== null && _b !== void 0 ? _b : []), reactionName], reactions: Object.assign(Object.assign({}, model.reactions), { [reactionName]: ((_c = model.reactions[reactionName]) !== null && _c !== void 0 ? _c : 0) + 1 }) });
+    });
+    model && dispatchReactable(referenceType, model);
+    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;
+};
+
+/**
+ * ```js
+ * import { deleteReaction } from '@amityco/ts-sdk'
+ * const success = await deleteReaction('post', 'foobar', 'like')
+ * ```
+ *
+ * Removes a {@link Amity.Reaction} from a {@link Amity.Reactable} object
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The removed result.
+ *
+ * @category Reaction API
+ * @async
+ **/
+const removeReaction = async (referenceType, referenceId, reactionName) => {
+    var _a, _b;
+    const client = getActiveClient();
+    client.log('reaction/removeReaction', {
+        referenceId,
+        referenceType,
+        reactionName,
+    });
+    await client.http.delete(`/api/v2/reactions`, { data: { referenceId, referenceType, reactionName } });
+    const model = await fetchReference(referenceType, referenceId);
+    dispatchReactable(referenceType, model);
+    return (_b = !((_a = model.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName))) !== null && _b !== void 0 ? _b : false;
+};
+/**
+ * ```js
+ * import { removeReaction } from '@amityco/ts-sdk'
+ * const success = removeReaction.optimistically('post', postId, 'like')
+ * ```
+ *
+ * Removes a {@link Amity.Reaction} from a {@link Amity.Reactable} object optimistically
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ **/
+removeReaction.optimistically = (referenceType, referenceId, reactionName) => {
+    var _a, _b;
+    const model = mutateCache(referenceType, referenceId, model => {
+        var _a, _b, _c;
+        if (!((_a = model.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName)))
+            return;
+        return Object.assign(Object.assign({}, model), { syncedAt: -1, reactionsCount: Math.max(0, model.reactionsCount - 1), myReactions: ((_b = model.myReactions) !== null && _b !== void 0 ? _b : []).filter(item => item !== reactionName), reactions: Object.assign(Object.assign({}, model.reactions), { [reactionName]: Math.max(0, ((_c = model.reactions[reactionName]) !== null && _c !== void 0 ? _c : 0) - 1) }) });
+    });
+    model && dispatchReactable(referenceType, model);
+    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;
+};
+
+/**
+ * ```js
+ * import { onReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onReactionRemoved(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reaction} has been removed
+ *
+ * @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',
+    },
+};
+
+/**
+ * ```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`);
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent(`v3.${referenceType}.didUpdate`, data);
+    return !!data;
+};
+
+/**
+ * ```js
+ * import { deleteReport } from '@amityco/ts-sdk'
+ * const unflagged = await deleteReport('post', postId)
+ * ```
+ *
+ * @param referenceType The type of thing to delete a report to, such as a post or a comment.
+ * @param referenceId The ID of the thing to delete a report to.
+ * @returns the deleted report result
+ *
+ * @category Report API
+ * @async
+ **/
+const deleteReport = async (referenceType, referenceId) => {
+    const client = getActiveClient();
+    client.log('report/deleteReport', { referenceType, referenceId });
+    const { domainName } = REFERENCE_TYPES[referenceType];
+    const { data } = await client.http.delete(`/api/v3/${domainName}/${referenceId}/unflag`);
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent(`v3.${referenceType}.didUpdate`, data);
+    return !!data;
+};
+
+/**
+ * ```js
+ * import { isReportedByMe } from '@amityco/ts-sdk'
+ * const isReported = await isReportedByMe('post', postId)
+ * ```
+ *
+ * @param referenceType The type of thing to check a report to, such as a post or a comment.
+ * @param referenceId The ID of the thing to check a report to.
+ * @returns `true` if the report is created by me, `false` if doesn't.
+ *
+ * @category Report API
+ * @async
+ **/
+const isReportedByMe = async (referenceType, referenceId) => {
+    var _a, _b;
+    const client = getActiveClient();
+    client.log('report/isReportedByMe', { referenceType, referenceId });
+    const { eventName, primaryKey } = REFERENCE_TYPES[referenceType];
+    const { result, isFlagByMe } = (_a = (await synchronousWSCall(client, eventName, {
+        [primaryKey]: referenceId,
+    }))) !== null && _a !== void 0 ? _a : {};
+    return (_b = result !== null && result !== void 0 ? result : isFlagByMe) !== null && _b !== void 0 ? _b : false;
+};
+
+/**
+ * ```js
+ * import { queryChannels } from '@amityco/ts-sdk'
+ * const channels = await queryChannels()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Channel} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+const queryChannels = async (query) => {
+    const client = getActiveClient();
+    client.log('channel/queryChannels', query);
+    // safe decapsulation
+    const _a = query !== null && query !== void 0 ? query : {}, { page, displayName, membership } = _a, params = __rest(_a, ["page", "displayName", "membership"]);
+    // API-FIX: parameters should be querystring.
+    // API-FIX: backend doesnt answer Amity.Response
+    // const { data } = await client.http.get<Amity.Response<Amity.Paged<ChannelPayload>>>(
+    const { data } = await client.http.get(`/api/v3/channels`, { params: Object.assign(Object.assign({}, params), { keyword: displayName, filter: membership, options: {
+                token: toToken(page, 'skiplimit'),
+            } }) });
+    const { paging } = data, response = __rest(data, ["paging"]);
+    decoratePayload(response);
+    ingestInCache(response);
+    const prevPage = toPage(paging === null || paging === void 0 ? void 0 : paging.previous);
+    const nextPage = toPage(paging === null || paging === void 0 ? void 0 : paging.next);
+    const { channels } = response;
+    return { data: toRecord(channels), prevPage, nextPage };
+};
+/**
+ * ```js
+ * import { queryChannels } from '@amityco/ts-sdk'
+ * const channels = queryChannels.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Channel} objects from cache
+ *
+ * @param query The query parameters
+ * @returns channels
+ *
+ * @category Channel API
+ */
+queryChannels.locally = (query) => {
+    const client = getActiveClient();
+    client.log('channel/queryChannels.locally', query);
+    // TODO
+};
+
+/**
+ * ```js
+ * import { getChannels } from '@amityco/ts-sdk'
+ * const channels = await getChannels(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Channel} objects
+ *
+ * @param channelIds the IDs of the {@link Amity.Channel} to fetch
+ * @returns the associated collection of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+const getChannels = async (channelIds) => {
+    const client = getActiveClient();
+    client.log('channel/getChannels', channelIds);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/channels/list`, { params: { channelIds } });
+    decoratePayload(data);
+    ingestInCache(data);
+    const { channels } = data;
+    return toRecord(channels);
+};
+/**
+ * ```js
+ * import { getChannels } from '@amityco/ts-sdk'
+ * const channels = getChannels.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Channel} objects from cache
+ *
+ * @param channelIds the IDs of the {@link Amity.Channel} to fetch
+ * @returns the associated collection of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ */
+getChannels.locally = (channelIds) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('channel/getChannels.locally', channelIds);
+    const cached = (_a = pullFromCache('channel', ...channelIds)) !== null && _a !== void 0 ? _a : [];
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) === channelIds.length)
+        return toRecord(cached);
+};
+
+/**
+ * ```js
+ * import { getChannel } from '@amityco/ts-sdk'
+ * const channel = await getChannel('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Channel} object
+ *
+ * @param channelId the ID of the {@link Amity.Channel} to fetch
+ * @returns the associated {@link Amity.Channel} object
+ *
+ * @category Channel API
+ * @async
+ */
+const getChannel = async (channelId) => {
+    const client = getActiveClient();
+    client.log('channel/getChannel', channelId);
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data } = await client.http.get(`/api/v3/channels/${channelId}`);
+    decoratePayload(data);
+    ingestInCache(data);
+    const { channels } = data;
+    return channels.find(channel => channel.channelId === channelId);
+};
+/**
+ * ```js
+ * import { getChannel } from '@amityco/ts-sdk'
+ * const channel = getChannel.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Channel} object from cache
+ *
+ * @param channelId the ID of the {@link Amity.Channel} to fetch
+ * @returns the associated {@link Amity.Channel} object
+ *
+ * @category Channel API
+ */
+getChannel.locally = (channelId) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('channel/getChannel.locally', channelId);
+    const [channel] = (_a = pullFromCache('channel', channelId)) !== null && _a !== void 0 ? _a : [];
+    return channel;
+};
+
+/**
+ * ```js
+ * import { createChannel } from '@amityco/ts-sdk'
+ * const created = await createChannel({ channelId: 'foobar', displayName: 'foobar' })
+ * ```
+ *
+ * Creates an {@link Amity.Channel}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Channel}
+ * @returns The newly created {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+const createChannel = async (bundle) => {
+    const client = getActiveClient();
+    client.log('user/createChannel', bundle);
+    const { data } = await client.http.post('/api/v3/channels', bundle);
+    decoratePayload(data);
+    ingestInCache(data);
+    // no need for event, fired by server
+    const { channels } = data;
+    return channels[0];
+};
+
+/**
+ * ```js
+ * import { updateChannel } from '@amityco/ts-sdk'
+ * const updated = await updateChannel(channelId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Channel} object
+ *
+ * @category Channel API
+ * @async
+ */
+const updateChannel = async (channelId, patch) => {
+    const client = getActiveClient();
+    client.log('channel/updateChannel', channelId, patch);
+    const { data } = await client.http.put(`/api/v3/channels/${channelId}`, patch);
+    decoratePayload(data);
+    ingestInCache(data);
+    // no need for event, fired by server
+    const { channels } = data;
+    return channels.find(channel => channel.channelId === channelId);
+};
+
+/**
+ * ```js
+ * import { deleteChannel } from '@amityco/ts-sdk'
+ * const success = await deleteChannel('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Channel}
+ *
+ * @param channelId The {@link Amity.Channel} ID to delete
+ * @return A success boolean if the {@link Amity.Channel} was deleted
+ *
+ * @category Channel API
+ * @async
+ */
+const deleteChannel = async (channelId) => {
+    const client = getActiveClient();
+    client.log('channel/deleteChannel', channelId);
+    // API-FIX: This endpoint has not been implemented yet.
+    await client.http.delete(`/api/v3/channels/${channelId}`);
+    const deleted = await getChannel(channelId);
+    // no need for event, fired by server
+    return deleted;
+};
+
+/**
+ * ```js
+ * import { joinChannel } from '@amityco/ts-sdk'
+ * const isJoined = await joinChannel('foobar')
+ * ```
+ *
+ * Joins a {@link Amity.Channel} object
+ *
+ * @param channelId the {@link Amity.Channel} to join
+ * @returns A success boolean if the {@link Amity.Channel} was joined
+ *
+ * @category Channel API
+ * @async
+ */
+const joinChannel = async (channelId) => {
+    const client = getActiveClient();
+    client.log('channel/joinChannel', channelId);
+    const { data } = await client.http.post(`/api/v3/channels/${channelId}/join`);
+    decoratePayload(data);
+    ingestInCache(data);
+    // no need for event, fired by server
+    const { channelUsers } = data;
+    return !!channelUsers.find(channelUser => (channelUser.channelId === channelId
+        && channelUser.membership === 'member'));
+};
+
+/**
+ * ```js
+ * import { leaveChannel } from '@amityco/ts-sdk'
+ * const isLeft = await leaveChannel('foobar')
+ * ```
+ *
+ * Leave a {@link Amity.Channel} object
+ *
+ * @param channelId the {@link Amity.Channel} to leave
+ * @returns A success boolean if the {@link Amity.Channel} was left
+ *
+ * @category Channel API
+ * @async
+ */
+const leaveChannel = async (channelId) => {
+    const client = getActiveClient();
+    client.log('channel/leaveChannel', channelId);
+    const { data } = await client.http.delete(`/api/v3/channels/${channelId}/leave`);
+    decoratePayload(data);
+    ingestInCache(data);
+    // no need for event, fired by server
+    const { channelUsers } = data;
+    return !!channelUsers.find(channelUser => (channelUser.channelId === channelId
+        && channelUser.membership !== 'member'));
+};
+
+/**
+ * ```js
+ * import { queryChannelMembers } from '@amityco/ts-sdk'
+ * const channelMembers = await queryChannelMembers({ channelId: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.ChannelUser} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.ChannelUser} objects
+ *
+ * @category Channel API
+ * @async
+ **/
+const queryChannelMembers = async (query) => {
+    const client = getActiveClient();
+    client.log('channel/queryChannelMembers', query);
+    const _a = query !== null && query !== void 0 ? query : {}, { page, channelId, membership } = _a, params = __rest(_a, ["page", "channelId", "membership"]);
+    const { data } = await client.http.get(`/api/v3/channels/${channelId}/users`, {
+        params: Object.assign(Object.assign({}, params), { filter: membership, options: {
+                token: toToken(page, 'skiplimit'),
+            } }),
+    });
+    const { paging } = data, response = __rest(data, ["paging"]);
+    decoratePayload(response);
+    ingestInCache(response);
+    const { channelUsers } = response;
+    const nextPage = toPage(paging.next);
+    const prevPage = toPage(paging.previous);
+    return { data: toRecord(channelUsers), nextPage, prevPage };
+};
+/**
+ * ```js
+ * import { queryChannelMembers } from '@amityco/ts-sdk'
+ * const channelMembers = await queryChannelMembers(query)
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns posts
+ *
+ * @category Post API
+ */
+queryChannelMembers.locally = (query) => {
+    const client = getActiveClient();
+    client.log('channel/queryChannelMembers', query);
+    // TODO
+};
+
+/**
+ * ```js
+ * import { addChannelMembers } from '@amityco/ts-sdk'
+ * const updated = await addChannelMembers(channelId, ['foo', 'bar'])
+ * ```
+ *
+ * Adds a list of {@link Amity.User} to a {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to perform
+ * @param userIds The list of IDs {@link Amity.User} to add
+ * @returns A success boolean if the {@link Amity.User} were added to the {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+const addChannelMembers = async (channelId, userIds) => {
+    const client = getActiveClient();
+    client.log('channel/addChannelMembers', channelId, userIds);
+    const { data } = await client.http.post(`/api/v3/channels/${channelId}/users`, { channelId, userIds });
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent('v3.channel.didAddUsers', {
+        channels: data.channels,
+    });
+    const { channelUsers } = data;
+    return !!channelUsers.find(channelUser => channelUser.channelId === channelId && channelUser.membership === 'member');
+};
+
+/**
+ * ```js
+ * import { removeChannelMembers } from '@amityco/ts-sdk'
+ * const updated = await removeChannelMembers(channelId, ['foo', 'bar'])
+ * ```
+ *
+ * Removes a list of {@link Amity.User} from a {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to perform
+ * @param userIds The list of IDs {@link Amity.User} to remove
+ * @returns A success boolean if the list of {@link Amity.User} were removed from the {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+const removeChannelMembers = async (channelId, userIds) => {
+    const client = getActiveClient();
+    client.log('channel/removeChannelMembers', channelId, userIds);
+    const { data } = await client.http.delete(`/api/v3/channels/${channelId}/users`, { data: { channelId, userIds } });
+    decoratePayload(data);
+    ingestInCache(data);
+    fireEvent('v3.channel.didRemoveUsers', {
+        channels: data.channels,
+    });
+    const { channelUsers } = data;
+    return !!channelUsers.find(channelUser => channelUser.channelId === channelId && channelUser.membership !== 'member');
+};
+
+/**
+ * ```js
+ * import { addChannelMembersRole } from '@amityco/ts-sdk'
+ * const updated = await addChannelMembersRole(channelId, 'foo', ['bar'])
+ * ```
+ *
+ * Adds an {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to perform
+ * @param roleId The ID of the {@link Amity.Role} to apply
+ * @param userId Array of IDs of the {@link Amity.User} to perform
+ * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.User} in the {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+const addChannelMembersRole = async (channelId, roleId, userIds) => {
+    const client = getActiveClient();
+    client.log('channel/addChannelMembersRole', channelId, roleId, userIds);
+    const { data } = await client.http.post(`/api/v3/channels/${channelId}/users/roles`, { channelId, role: roleId, userIds });
+    decoratePayload(data);
+    ingestInCache(data);
+    const { channelUsers } = data;
+    return !!channelUsers.find(channelUser => channelUser.channelId === channelId && channelUser.roles.includes(roleId));
+};
+
+/**
+ * ```js
+ * import { removeChannelMembersRole } from '@amityco/ts-sdk'
+ * const updated = await removeChannelMembersRole(channelId, 'foo', ['bar'])
+ * ```
+ *
+ * Removes an {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to perform
+ * @param roleId The ID of the {@link Amity.Role} to apply
+ * @param userId Array of IDs of the {@link Amity.User} to perform
+ * @returns A success boolean if the {@link Amity.Role} were removed from list of {@link Amity.User} in the {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+const removeChannelMembersRole = async (channelId, roleId, userIds) => {
+    const client = getActiveClient();
+    client.log('channel/removeChannelMembersRole', channelId, roleId, userIds);
+    const { data } = await client.http.delete(`/api/v3/channels/${channelId}/users/roles`, { data: { channelId, role: roleId, userIds } });
+    decoratePayload(data);
+    ingestInCache(data);
+    const { channelUsers } = data;
+    return !!channelUsers.find(channelUser => channelUser.channelId === channelId && !channelUser.roles.includes(roleId));
+};
+
+/**
+ * ```js
+ * import { onChannelUpdated } from '@amityco/ts-sdk'
+ * const dispose = onChannelUpdated(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} have been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelUpdated = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.channels[0]);
+    };
+    return createEventSubscriber(client, 'onChannelUpdated', 'v3.channel.didUpdate', filter);
+};
+
+/**
+ * ```js
+ * import { onChannelDeleted } from '@amityco/ts-sdk'
+ * const dispose = onChannelDeleted(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} have been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelDeleted = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.channels[0]);
+    };
+    return createEventSubscriber(client, 'onChannelDeleted', 'v3.channel.didDelete', filter);
+};
+
+/**
+ * ```js
+ * import { onChannelJoined } from '@amityco/ts-sdk'
+ * const dispose = onChannelJoined(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} was joined
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelJoined = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.channels[0]);
+    };
+    return createEventSubscriber(client, 'onChannelJoined', 'v3.channel.didJoin', filter);
+};
+
+/**
+ * ```js
+ * import { onChannelLeft } from '@amityco/ts-sdk'
+ * const dispose = onChannelLeft(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} was left
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelLeft = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.channels[0]);
+    };
+    return createEventSubscriber(client, 'onChannelLeft', 'v3.channel.didLeave', filter);
+};
+
+/**
+ * ```js
+ * import { onMemberAdded } from '@amityco/ts-sdk'
+ * const dispose = onMemberAdded(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onMemberAdded = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.channels[0]);
+    };
+    return createEventSubscriber(client, 'onMemberAdded', 'v3.channel.didAddUsers', filter);
+};
+
+/**
+ * ```js
+ * import { onMemberRemoved } from '@amityco/ts-sdk'
+ * const dispose = onMemberRemoved(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been removed from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onMemberRemoved = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.channels[0]);
+    };
+    return createEventSubscriber(client, 'onMemberRemoved', 'v3.channel.didRemoveUsers', filter);
+};
+
+/**
+ * ```js
+ * import { observeChannel } from '@amityco/ts-sdk'
+ *
+ * let channel = {}
+ * const dispose = observeChannel(channelId, ({ data }) => channel = data)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Channel}
+ *
+ * @param channelId the ID of the channel to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the channel
+ *
+ * @category Channel Observer
+ */
+const observeChannel = (channelId, callback) => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    log(`observeChannel(tmpid: ${timestamp}) > listen`);
+    // wrapper function to make sure
+    const router = (result, action) => {
+        var _a, _b, _c;
+        // filter function
+        if (((_a = result.data) === null || _a === void 0 ? void 0 : _a.channelId) !== channelId)
+            return;
+        if (callback instanceof Function)
+            return callback(result);
+        if (action !== 'onFetch')
+            (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, result);
+        (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
+    };
+    const disposers = [];
+    disposers.push(onChannelUpdated(data => router({ data }, 'onUpdate')), onChannelDeleted(data => router({ data }, 'onDelete')), onChannelJoined(data => router({ data }, 'onJoin')), onChannelLeft(data => router({ data }, 'onLeft')), onMemberAdded(data => router({ data }, 'onMemberAdded')), onMemberRemoved(data => router({ data }, 'onMemberRemoved')));
+    runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));
+    return () => {
+        log(`observeChannel(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { onMessageCreated } from '@amityco/ts-sdk'
+ * const dispose = onMessageCreated(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageCreated = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'message/onMessageCreated', 'v3.message.didCreate', filter);
+};
+
+/**
+ * ```js
+ * import { onMessageUpdated } from '@amityco/ts-sdk'
+ * const dispose = onMessageUpdated(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageUpdated = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'message/onMessageUpdated', 'v3.message.didUpdate', filter);
+};
+
+/**
+ * ```js
+ * import { onMessageDeleted } from '@amityco/ts-sdk'
+ * const dispose = onMessageDeleted(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} was deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+const onMessageDeleted = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.messages[0]);
+    };
+    return createEventSubscriber(client, 'message/onMessageDeleted', 'v3.message.didDelete', filter);
+};
+
+/**
+ * ```js
+ * import { observeMessage } from '@amityco/ts-sdk'
+ *
+ * let message = {}
+ * const unsub = observeMessage(messageId, updated => message = updated)
+ * ```
+ *
+ * Observe all mutations on a {@link Amity.Message} given a single messageId
+ *
+ * @param client the client to observe the message with
+ * @param messageId the ID of the message to observe
+ * @param callback the function to call when new data are available
+ * @param policy a query policy option for this observer
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the message
+ *
+ * @category Message Observer
+ */
+const observeMessage = (messageId, callback, policy = 'cache_then_server') => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    log(`observeMessage(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.messageId) !== messageId)
+            return;
+        if (callback instanceof Function)
+            return callback(result);
+        if (action !== 'onFetch')
+            (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, result);
+        (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
+    };
+    const disposers = [];
+    disposers.push(onMessageUpdated(message => router(message, 'onUpdate')), onMessageDeleted(message => router(message, 'onDelete')));
+    if (policy !== 'no_fetch') {
+        runQuery(createQuery(getMessage, messageId), (result) => result.data && router(result, 'onFetch'), queryOptions(policy));
+    }
+    return () => {
+        log(`observeMessages(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * 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());
+    };
+};
+
+/**
+ * ```js
+ * import { onCommunityCreated } from '@amityco/ts-sdk'
+ * const dispose = onCommunityCreated(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@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) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.communities[0]);
+    };
+    return createEventSubscriber(client, 'onCommunityCreated', 'v3.community.didCreate', filter);
+};
+
+/**
+ * ```js
+ * import { onCommunityUpdated } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUpdated(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Community} have 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) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.communities[0]);
+    };
+    return createEventSubscriber(client, 'onCommunityUpdated', 'v3.community.didUpdate', filter);
+};
+
+/**
+ * ```js
+ * import { onCommunityDeleted } from '@amityco/ts-sdk'
+ * const dispose = onCommunityDeleted(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Community} have 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) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.communities[0]);
+    };
+    return createEventSubscriber(client, 'onCommunityDeleted', 'v3.community.didDelete', filter);
+};
+
+/**
+ * ```js
+ * import { onCommunityJoined } from '@amityco/ts-sdk'
+ * const dispose = onCommunityJoined(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Community} was joined
+ *
+ * @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);
+};
+
+/**
+ * ```js
+ * import { onCommunityLeft } from '@amityco/ts-sdk'
+ * const dispose = onCommunityLeft(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Community} was 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 onCommunityLeft = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        decoratePayload(payload);
+        ingestInCache(payload);
+        callback(payload.communities[0]);
+    };
+    return createEventSubscriber(client, 'onCommunityLeft', 'v3.community.didLeave', filter);
+};
+
+/**
+ * ```js
+ * import { observeCommunity } from '@amityco/ts-sdk'
+ *
+ * let community = {}
+ * const dispose = observeCommunity(communityId, updated => community = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Community}
+ *
+ * @param communityId the ID of the community to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the community
+ *
+ * @category Community Observer
+ */
+const observeCommunity = (communityId, callback) => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    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;
+        if (callback instanceof Function)
+            return callback(result);
+        if (action !== 'onFetch')
+            (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, result);
+        (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
+    };
+    const disposers = [];
+    disposers.push(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'));
+    return () => {
+        log(`observeCommunity(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { queryGlobalFeed } from '@amityco/ts-sdk'
+ * const posts = await queryGlobalFeed()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @category Feed API
+ * @async
+ **/
+const queryGlobalFeed = async (query) => {
+    const client = getActiveClient();
+    client.log('feed/queryGlobalFeed', query);
+    const _a = query !== null && query !== void 0 ? query : {}, { page } = _a, params = __rest(_a, ["page"]);
+    const { data } = await client.http.get(`/api/v4/me/global-feeds`, { params: Object.assign(Object.assign({}, params), { options: {
+                token: toToken(page, 'skiplimit')
+            } }) });
+    const { paging } = data, response = __rest(data, ["paging"]);
+    decoratePayload(response);
+    ingestInCache(response);
+    const { posts } = response;
+    const nextPage = toPage(paging.next);
+    const prevPage = toPage(paging.previous);
+    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'
+ *
+ * let posts = []
+ * const unsub = observePosts({
+ *   targetType: Amity.PostTargetType,
+ *   targetId: Amity.Post['targetId'],
+ * }, post => merge(posts, post))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given target object
+ *
+ * @param targetType the type of the target
+ * @param targetId the ID of the target
+ * @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 Post Observer
+ */
+const observePosts = (params, callback) => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    log(`observePosts(tmpid: ${timestamp}) > listen`);
+    const disposers = [];
+    const router = (post, action) => {
+        var _a, _b;
+        if (params.targetId !== post.targetId
+            || params.targetType !== post.targetType)
+            return;
+        if (callback instanceof Function)
+            return callback(post);
+        (_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')));
+    return () => {
+        log(`observePosts(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { observePost } from '@amityco/ts-sdk'
+ *
+ * let post = {}
+ * const dispose = observePost(postId, updated => post = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Post}
+ *
+ * @param postId the ID of the post to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the post
+ *
+ * @category Post Observer
+ */
+const observePost = (postId, callback, policy = 'cache_then_server') => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    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;
+        if (callback instanceof Function)
+            return callback(result);
+        if (action !== 'onFetch')
+            (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, result);
+        (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
+    };
+    const disposers = [];
+    disposers.push(onPostUpdated(data => router({ data }, 'onUpdate')), onPostDeleted(data => router({ data }, 'onDelete')));
+    runQuery(createQuery(getPost, postId), (result) => result.data && 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'
+ *
+ * let comments = []
+ * const unsub = observeComments(postId, comment => merge(comments, comment))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Comment} for a given {@link Amity.Post} object
+ *
+ * @param postId the ID of the post where to observe the comments
+ * @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 comments
+ *
+ * @category Comment Observer
+ */
+const observeComments = (postId, callback) => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    log(`observeComments(tmpid: ${timestamp}) > listen`);
+    const disposers = [];
+    const router = (comment, action) => {
+        var _a, _b;
+        if (comment.referenceId !== postId)
+            return;
+        if (callback instanceof Function)
+            return callback(comment);
+        (_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')));
+    return () => {
+        log(`observeComments(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { observeComment } from '@amityco/ts-sdk'
+ *
+ * let comment = {}
+ * const dispose = observeComment(commentId, ({ data }) => comment = data)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Comment}
+ *
+ * @param commentId the ID of the comment to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
+ *
+ * @category Comment Observer
+ */
+const observeComment = (commentId, callback, policy = 'cache_then_server') => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    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;
+        if (callback instanceof Function)
+            return callback(result);
+        if (action !== 'onFetch')
+            (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, result);
+        (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
+    };
+    const disposers = [];
+    disposers.push(onCommentUpdated(data => router({ data }, 'onUpdate')), onCommentDeleted(data => router({ data }, 'onDelete')));
+    runQuery(createQuery(getComment, commentId), result => result.data && router(result, 'onFetch'), queryOptions(policy));
+    return () => {
+        log(`observeComment(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+exports.addChannelMembers = addChannelMembers;
+exports.addChannelMembersRole = addChannelMembersRole;
+exports.addCommunityMembers = addCommunityMembers;
+exports.addCommunityMembersRole = addCommunityMembersRole;
+exports.addReaction = addReaction;
+exports.clearCache = clearCache;
+exports.connectClient = connectClient;
+exports.createCache = createCache;
+exports.createChannel = createChannel;
+exports.createClient = createClient;
+exports.createComment = createComment;
+exports.createCommunity = createCommunity;
+exports.createFile = createFile;
+exports.createMessage = createMessage;
+exports.createPost = createPost;
+exports.createQuery = createQuery;
+exports.createReport = createReport;
+exports.decorateModel = decorateModel;
+exports.decorateModels = decorateModels;
+exports.decoratePayload = decoratePayload;
+exports.deleteChannel = deleteChannel;
+exports.deleteComment = deleteComment;
+exports.deleteCommunity = deleteCommunity;
+exports.deleteFile = deleteFile;
+exports.deleteMessage = deleteMessage;
+exports.deletePost = deletePost;
+exports.deleteReport = deleteReport;
+exports.disconnectClient = disconnectClient;
+exports.dropFromCache = dropFromCache;
+exports.enableCache = enableCache;
+exports.fileUrlWithSize = fileUrlWithSize;
+exports.filterByPropEquality = filterByPropEquality;
+exports.getActiveClient = getActiveClient;
+exports.getChannel = getChannel;
+exports.getChannels = getChannels;
+exports.getComment = getComment;
+exports.getComments = getComments;
+exports.getCommunities = getCommunities;
+exports.getCommunity = getCommunity;
+exports.getFile = getFile;
+exports.getMessage = getMessage;
+exports.getMessages = getMessages;
+exports.getPost = getPost;
+exports.getPosts = getPosts;
+exports.getRole = getRole;
+exports.getUser = getUser;
+exports.getUsers = getUsers;
+exports.ingestInCache = ingestInCache;
+exports.isAfterBefore = isAfterBefore;
+exports.isConnected = isConnected;
+exports.isFetcher = isFetcher;
+exports.isFresh = isFresh;
+exports.isLocal = isLocal;
+exports.isMutator = isMutator;
+exports.isOffline = isOffline;
+exports.isPaged = isPaged;
+exports.isReportedByMe = isReportedByMe;
+exports.isSkipLimit = isSkipLimit;
+exports.isSyncable = isSyncable;
+exports.isSynced = isSynced;
+exports.joinChannel = joinChannel;
+exports.joinCommunity = joinCommunity;
+exports.leaveChannel = leaveChannel;
+exports.leaveCommunity = leaveCommunity;
+exports.memoryStore = memoryStore;
+exports.memoryStores = memoryStores;
+exports.mergeInCache = mergeInCache;
+exports.mutateCache = mutateCache;
+exports.observeChannel = observeChannel;
+exports.observeComment = observeComment;
+exports.observeComments = observeComments;
+exports.observeCommunity = observeCommunity;
+exports.observeFile = observeFile;
+exports.observeMessage = observeMessage;
+exports.observeMessages = observeMessages;
+exports.observePost = observePost;
+exports.observePosts = observePosts;
+exports.observeUser = observeUser;
+exports.onChannelDeleted = onChannelDeleted;
+exports.onChannelJoined = onChannelJoined;
+exports.onChannelLeft = onChannelLeft;
+exports.onChannelUpdated = onChannelUpdated;
+exports.onClientDisconnected = onClientDisconnected;
+exports.onCommentCreated = onCommentCreated;
+exports.onCommentDeleted = onCommentDeleted;
+exports.onCommentUpdated = onCommentUpdated;
+exports.onCommunityCreated = onCommunityCreated;
+exports.onCommunityDeleted = onCommunityDeleted;
+exports.onCommunityJoined = onCommunityJoined;
+exports.onCommunityLeft = onCommunityLeft;
+exports.onCommunityUpdated = onCommunityUpdated;
+exports.onMemberAdded = onMemberAdded;
+exports.onMemberRemoved = onMemberRemoved;
+exports.onMessageCreated = onMessageCreated;
+exports.onMessageDeleted = onMessageDeleted;
+exports.onMessageUpdated = onMessageUpdated;
+exports.onPostCreated = onPostCreated;
+exports.onPostDeleted = onPostDeleted;
+exports.onPostUpdated = onPostUpdated;
+exports.onReactionRemoved = onReactionRemoved;
+exports.onUserUpdated = onUserUpdated;
+exports.persistentStore = persistentStore;
+exports.pullFromCache = pullFromCache;
+exports.pushToCache = pushToCache;
+exports.queryChannelMembers = queryChannelMembers;
+exports.queryChannels = queryChannels;
+exports.queryComments = queryComments;
+exports.queryCommunities = queryCommunities;
+exports.queryCommunityMembers = queryCommunityMembers;
+exports.queryGlobalFeed = queryGlobalFeed;
+exports.queryMessages = queryMessages;
+exports.queryOptions = queryOptions;
+exports.queryPosts = queryPosts;
+exports.queryRoles = queryRoles;
+exports.queryUsers = queryUsers;
+exports.removeChannelMembers = removeChannelMembers;
+exports.removeChannelMembersRole = removeChannelMembersRole;
+exports.removeCommunityMembers = removeCommunityMembers;
+exports.removeCommunityMembersRole = removeCommunityMembersRole;
+exports.removeReaction = removeReaction;
+exports.runQuery = runQuery;
+exports.sliceByPaging = sliceByPaging;
+exports.sortByChannelSegment = sortByChannelSegment;
+exports.sortByDisplayName = sortByDisplayName;
+exports.sortByFirstCreated = sortByFirstCreated;
+exports.sortByLastActivity = sortByLastActivity;
+exports.sortByLastCreated = sortByLastCreated;
+exports.sortBySegmentNumber = sortBySegmentNumber;
+exports.syncInCache = syncInCache;
+exports.toPage = toPage;
+exports.toToken = toToken;
+exports.updateChannel = updateChannel;
+exports.updateComment = updateComment;
+exports.updateCommunity = updateCommunity;
+exports.updateMessage = updateMessage;
+exports.updatePost = updatePost;
+exports.updateUser = updateUser;