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

package/dist/index.umd.js

@@ -0,0 +1,4880 @@
+var Amity = (function (exports, jsBase64, nativeIdGenerator, debug, axios, HttpAgent, io, mitt, AsyncStorage) {
+  'use strict';
+
+  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;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+  return exports;
+
+}({}, jsBase64, nativeIdGenerator, debug, axios, HttpAgent, io, mitt, AsyncStorage));