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

package/dist/stream/events/onStreamStarted.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ```js
+ * import { onStreamStarted } from '@amityco/ts-sdk'
+ * const dispose = onStreamStarted(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Stream} has started airing
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export declare const onStreamStarted: (callback: Amity.Listener<Amity.Stream>) => Amity.Unsubscriber;
+//# sourceMappingURL=onStreamStarted.d.ts.map

package/dist/stream/events/onStreamStarted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onStreamStarted.d.ts","sourceRoot":"","sources":["../../../src/stream/events/onStreamStarted.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,aAChB,MAAM,QAAQ,CAAC,MAAM,MAAM,CAAC,KACrC,MAAM,YAeR,CAAA"}

package/dist/stream/events/onStreamStopped.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ```js
+ * import { onStreamStopped } from '@amityco/ts-sdk'
+ * const dispose = onStreamStopped(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Stream} has stopped airing
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export declare const onStreamStopped: (callback: Amity.Listener<Amity.Stream>) => Amity.Unsubscriber;
+//# sourceMappingURL=onStreamStopped.d.ts.map

package/dist/stream/events/onStreamStopped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onStreamStopped.d.ts","sourceRoot":"","sources":["../../../src/stream/events/onStreamStopped.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,aAChB,MAAM,QAAQ,CAAC,MAAM,MAAM,CAAC,KACrC,MAAM,YAeR,CAAA"}

package/dist/user/api/getUser.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ```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
+ */
+export declare const getUser: {
+    (userId: Amity.User['userId']): Promise<Amity.User>;
+    /**
+     * ```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
+     */
+    locally(userId: Amity.User['userId']): Amity.User;
+};
+//# sourceMappingURL=getUser.d.ts.map

package/dist/user/api/getUser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getUser.d.ts","sourceRoot":"","sources":["../../../src/user/api/getUser.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO;aACV,MAAM,IAAI,CAAC,QAAQ,CAAC;IAiB9B;;;;;;;;;;;;OAYG;oBAEO,MAAM,IAAI,CAAC,QAAQ,CAAC;CAhB7B,CAAA"}

package/dist/user/api/getUsers.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ```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
+ */
+export declare const getUsers: {
+    (userIds: Amity.User['userId'][]): Promise<Record<string, Amity.User>>;
+    /**
+     * ```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
+     */
+    locally(userIds: Amity.User['userId'][]): Record<string, Amity.User> | undefined;
+};
+//# sourceMappingURL=getUsers.d.ts.map

package/dist/user/api/getUsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getUsers.d.ts","sourceRoot":"","sources":["../../../src/user/api/getUsers.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ;cACV,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE;IAkBjC;;;;;;;;;;;;OAYG;qBAEQ,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE;CAhBhC,CAAA"}

package/dist/user/api/index.d.ts

@@ -0,0 +1,5 @@
+export { getUser } from './getUser';
+export { getUsers } from './getUsers';
+export { queryUsers } from './queryUsers';
+export { updateUser } from './updateUser';
+//# sourceMappingURL=index.d.ts.map

package/dist/user/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/user/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA"}

package/dist/user/api/queryUsers.d.ts

@@ -0,0 +1,43 @@
+/**
+ * ```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
+ */
+export declare const queryUsers: {
+    (query?: {
+        displayName?: Amity.User['displayName'];
+        filter?: "all" | "flagged" | undefined;
+        sortBy?: "displayName" | "firstCreated" | "lastCreated" | undefined;
+        page?: Amity.Page | undefined;
+    } | undefined): Promise<{
+        data: Record<string, Amity.User>;
+        prevPage: Amity.Page | null;
+        nextPage: Amity.Page | null;
+    }>;
+    /**
+     * ```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
+     */
+    locally(query: Parameters<typeof queryUsers>[0]): void;
+};
+//# sourceMappingURL=queryUsers.d.ts.map

package/dist/user/api/queryUsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryUsers.d.ts","sourceRoot":"","sources":["../../../src/user/api/queryUsers.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU;;sBAEL,MAAM,IAAI,CAAC,aAAa,CAAC;;;;;;;;;IA2C3C;;;;;;;;;;;;;OAaG;mBAEM,WAAW,iBAAiB,CAAC,CAAC,CAAC,CAAC;CAjBxC,CAAA"}

package/dist/user/api/updateUser.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ```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
+ */
+export declare const updateUser: (userId: Amity.User['userId'], patch: Patch<Amity.User, 'displayName' | 'description' | 'avatarFileId' | 'metadata'>) => Promise<Amity.User>;
+//# sourceMappingURL=updateUser.d.ts.map

package/dist/user/api/updateUser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateUser.d.ts","sourceRoot":"","sources":["../../../src/user/api/updateUser.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,WACb,MAAM,IAAI,CAAC,QAAQ,CAAC,SACrB,MAAM,MAAM,IAAI,EAAE,aAAa,GAAG,aAAa,GAAG,cAAc,GAAG,UAAU,CAAC,wBAqBtF,CAAA"}

package/dist/user/events/index.d.ts

@@ -0,0 +1,2 @@
+export * from './onUserUpdated';
+//# sourceMappingURL=index.d.ts.map

package/dist/user/events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/user/events/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA"}

package/dist/user/events/onUserUpdated.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ```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
+ */
+export declare const onUserUpdated: (callback: Amity.Listener<Amity.User>) => Amity.Unsubscriber;
+//# sourceMappingURL=onUserUpdated.d.ts.map

package/dist/user/events/onUserUpdated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onUserUpdated.d.ts","sourceRoot":"","sources":["../../../src/user/events/onUserUpdated.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,aACd,MAAM,QAAQ,CAAC,MAAM,IAAI,CAAC,uBAgBrC,CAAA"}

package/dist/user/observers/index.d.ts

@@ -0,0 +1,2 @@
+export { observeUser } from './observeUser';
+//# sourceMappingURL=index.d.ts.map

package/dist/user/observers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/user/observers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/dist/user/observers/observeUser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ```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
+ */
+export declare const observeUser: <Events extends ["onFetch", "onUpdate"]>(userId: string, callback: Amity.ObjectListener<{
+    data?: Amity.User | undefined;
+} & Amity.QueryMetadata, Events>) => Amity.Unsubscriber;
+//# sourceMappingURL=observeUser.d.ts.map

package/dist/user/observers/observeUser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observeUser.d.ts","sourceRoot":"","sources":["../../../src/user/observers/observeUser.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,mDACd,MAAM;;qCAEb,MAAM,YAsCR,CAAA"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@amityco/ts-sdk",
+  "version": "0.0.1-02f0fa3.0",
+  "license": "CC-BY-ND-4.0",
+  "author": "amity.co <developers@amity.co> (https://amity.co)",
+  "description": "Amity Social Cloud Typescript SDK",
+  "keywords": [
+    "amity",
+    "amity.co",
+    "social",
+    "messaging",
+    "chat",
+    "video",
+    "ts",
+    "js"
+  ],
+  "main": "./dist/index.cjs.js",
+  "module": "./dist/index.esm.js",
+  "unpkg": "./dist/index.umd.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=12",
+    "npm": ">=6"
+  },
+  "scripts": {
+    "clean": "rimraf ./dist",
+    "prebuild": "yarn run clean",
+    "build": "rollup -c ./rollup.config.js",
+    "prewatch": "yarn run clean",
+    "watch": "rollup -w -c ./rollup.config.js"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^20.0.0",
+    "@rollup/plugin-node-resolve": "^13.0.4",
+    "@types/axios": "^0.14.0",
+    "@types/debug": "^4.1.5",
+    "@types/node": "^14.0.11",
+    "@types/socket.io-client": "^1.4.34",
+    "chalk": "^4.1.2",
+    "concurrently": "^6.1.0",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.56.3",
+    "rollup-plugin-typescript2": "^0.30.0",
+    "tslib": "^2.1.0",
+    "typescript": "^4.4.2"
+  },
+  "dependencies": {
+    "@react-native-async-storage/async-storage": "^1.15.5",
+    "agentkeepalive": "^4.1.3",
+    "axios": "^0.21.1",
+    "debug": "^4.3.1",
+    "js-base64": "^3.6.1",
+    "mitt": "^3.0.0",
+    "react-native-uuid": "^2.0.1",
+    "socket.io-client": "2.2.0",
+    "typescript": "^4.4.2"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,41 @@
+import chalk from 'chalk'
+import commonjs from '@rollup/plugin-commonjs'
+import resolve from '@rollup/plugin-node-resolve'
+import typescript from 'rollup-plugin-typescript2'
+
+import pkg from './package.json'
+
+export default {
+  input: 'src/index.ts',
+  output: [
+    {
+      file: pkg.main,
+      format: 'cjs',
+    },
+    {
+      file: pkg.module,
+      format: 'es',
+    },
+    {
+      file: pkg.unpkg,
+      format: 'iife',
+      name: 'Amity',
+
+    }
+  ],
+  external: Object.keys(pkg.dependencies),
+  plugins: [
+    resolve(),
+    commonjs(),
+    typescript({
+      useTsconfigDeclarationDir: true,
+    }),
+  ],
+  onwarn: warning => {
+    // we don't allow circular dependencies
+    if (warning.code === 'CIRCULAR_DEPENDENCY') {
+      console.log(chalk.red('error'), warning.message)
+      process.exit(1)
+    }
+  }
+};

package/src/@types/core/cache.ts

@@ -0,0 +1,22 @@
+export {}
+
+declare global {
+  namespace Amity {
+    /**
+     * The typing of cache allows to distribute the typings properly for each values
+     * of T, so that there will be a proper auto-completion for K = "user" or K = "file"
+     * @hidden
+     */
+    type Cache = {
+      lookup: Record<string, string>,
+    } & {
+      [K in keyof Amity.Model]?: Amity.Store<Amity.Model[K]>
+    }
+
+    /**
+     * Possible stores should be restricted to the one to fit in cache
+     * @hidden
+     */
+    type Domain = keyof Amity.Model
+  }
+}

package/src/@types/core/errors.ts

@@ -0,0 +1,34 @@
+export {}
+
+declare global {
+  namespace Amity {
+    const enum ErrorLevel {
+      ERROR = 'error',
+      FATAL = 'fatal',
+    }
+
+    const enum ServerError {
+      BAD_REQUEST = 400000,
+      UNAUTHORIZED = 400100,
+      PERMISSION_DENIED = 400301,
+      ITEM_NOT_FOUND = 400400,
+      CONFLICT = 400900,
+      FORBIDDEN = 400300,
+      USER_IS_MUTED = 400302,
+      USER_IS_BANNED = 400304,
+      CHANNEL_IS_MUTED = 400303,
+      NUMBER_OF_MEMBERS_EXCEEDED = 400305,
+      MAX_REPETITION_EXCEEDED = 400307,
+      BAN_WORD_FOUND = 400308,
+      LINK_NOT_ALLOWED = 400309,
+      BUSINESS_ERROR = 500000,
+    }
+
+    const enum ClientError {
+      UNKNOWN_ERROR = 800000,
+      INVALID_PARAMETERS = 800110,
+      QUERY_IN_PROGRESS = 800170,
+      CONNECTION_ERROR = 800210,
+    }
+  }
+}

package/src/@types/core/events.ts

@@ -0,0 +1,60 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type Listener<T = any> = (params: T) => void
+
+    type ObjectListener<T, K extends string[]> = Listener<T> | {
+      onEvent?: (event: K[number], params: T) => void
+    } & {
+      [P in K[number]]?: Listener<T>
+    }
+
+    type Unsubscriber = () => void
+
+    type Subscriber<T = any> = (fn: Amity.Listener<T>) => Unsubscriber
+
+    type Events = {
+      disconnected: string | undefined
+      'v3.user.didUpdate': Amity.UserPayload
+
+      'v3.channel.didCreate': Amity.ChannelPayload
+      'v3.channel.didUpdate': Amity.ChannelPayload
+      'v3.channel.didDelete': Amity.ChannelPayload
+      'v3.channel.didJoin': Amity.ChannelPayload
+      'v3.channel.didLeave': Amity.ChannelPayload
+      'v3.channel.didAddUsers': Amity.ChannelPayload
+      'v3.channel.didRemoveUsers': Amity.ChannelPayload
+      'v3.channel.didBan': Amity.ChannelPayload
+      'v3.channel.didUnban': Amity.ChannelPayload
+
+      'v3.message.didCreate': Amity.MessagePayload
+      'v3.message.didUpdate': Amity.MessagePayload
+      'v3.message.didDelete': Amity.MessagePayload
+
+      'video-streaming.didRecord': Amity.StreamPayload
+      'video-streaming.didStart': Amity.StreamPayload
+      'video-streaming.didStop': Amity.StreamPayload
+
+      // these events have a different shape because they're not supported
+      // by backend yet. since all is internal and wrapped in emitter,
+      // it should be fairly easy and non-breaking to refactor this if
+      // backend were to add events later on.
+      'v3.community.didCreate': Amity.CommunityPayload
+      'v3.community.didUpdate': Amity.CommunityPayload
+      'v3.community.didDelete': Amity.CommunityPayload
+      'v3.community.didJoin': Amity.CommunityPayload
+      'v3.community.didLeave': Amity.CommunityPayload
+      'v3.community.didAddUsers': Amity.CommunityPayload
+      'v3.community.didRemoveUsers': Amity.CommunityPayload
+
+      'v3.post.didCreate': Amity.PostPayload
+      'v3.post.didUpdate': Amity.PostPayload
+      'v3.post.didDelete': Amity.PostPayload
+
+      'v3.comment.didCreate': Amity.CommentPayload
+      'v3.comment.didUpdate': Amity.CommentPayload
+      'v3.comment.didDelete': Amity.CommentPayload
+    }
+  }
+}

package/src/@types/core/model.ts

@@ -0,0 +1,51 @@
+export {}
+
+declare global {
+  namespace Amity {
+    /**
+     * type map of "domain name -> ASC model"
+     * @hidden
+     */
+    type Model = {
+      'user': Amity.User
+      'file': Amity.File
+      'role': Amity.Role
+
+      'channel': Amity.Channel
+      'channelUsers': Amity.Membership<'channel'>
+      'message': Amity.Message
+
+      'community': Amity.Community
+      'communityUsers': Amity.Membership<'community'>
+      'post': Amity.Post
+      'comment': Amity.Comment
+
+      'stream': Amity.Stream
+    }
+
+    /**
+     * Definition of the minimal set of properties necessary to identify
+     * successfully a model.
+     * @hidden
+     */
+    type Minimal = {
+      'user': Pick<Amity.User, 'userId'>
+      'file': Pick<Amity.File, 'fileId'>
+      'role': Pick<Amity.Role, 'roleId'>
+
+      'channel': Pick<Amity.Channel, 'channelId'>
+      'channelUsers': Pick<Amity.Membership<'channel'>, 'channelId' | 'userId'>
+      'message': Pick<Amity.Message, 'messageId'>
+
+      'community': Pick<Amity.Community, 'communityId'>
+      'communityUsers': Pick<
+        Amity.Membership<'community'>,
+        'communityId' | 'userId'
+      >
+      'post': Pick<Amity.Post, 'postId'>
+      'comment': Pick<Amity.Comment, 'commentId'>
+
+      'stream': Pick<Amity.Stream, 'streamId'>
+    }
+  }
+}

package/src/@types/core/payload.ts

@@ -0,0 +1,102 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type Payloads = {
+      user: Amity.UserPayload
+      file: Amity.FilePayload
+      role: Amity.RolePayload
+      channel: Amity.ChannelPayload
+      channelUser: Amity.ChannelMembershipPayload
+      message: Amity.MessagePayload
+      community: Amity.CommunityPayload
+      communityUser: Amity.CommunityMembershipPayload
+      post: Amity.PostPayload
+      comment: Amity.CommentPayload
+      stream: Amity.StreamPayload
+    }
+
+    type UserPayload = {
+      users: Amity.User[]
+      files: Amity.File<'image'>[]
+    }
+
+    // API-FIX: backend should return a payload like { files: Amity.File<T>[] }
+    type CreateFilePayload<T extends Amity.FileType = any> = Amity.File<T>[]
+    type FilePayload<T extends Amity.FileType = any> = Amity.File<T>
+
+    type RolePayload = {
+      roles: Amity.Role[]
+    }
+
+    type ChannelPayload<T extends Amity.ChannelType = any> = {
+      channels: Amity.Channel<T>[]
+      channelUsers?: Amity.Membership<'channel'>[]
+      users?: Amity.User[]
+      files?: Amity.File[]
+    }
+
+    type ChannelMembershipPayload = {
+      channels?: Amity.Channel[]
+      channelUsers: Amity.Membership<'channel'>[]
+      users?: Amity.User[]
+      files?: Amity.File[]
+    }
+
+    type MessagePayload<T extends Amity.MessageContentType = any> = {
+      messages: Amity.Message<T>[]
+      users?: Amity.User[]
+      files?: Amity.File[]
+    }
+
+    type StreamPayload = {
+      videoStreamings: Amity.Stream[]
+      users?: Amity.User[]
+      files?: Amity.File<'image'>[]
+    }
+
+    type CommunityPayload = {
+      communities: Amity.Community[]
+      communityUsers?: Amity.Membership<'community'>[]
+      categories?: Amity.Category[]
+      feeds?: Amity.Feed[]
+      users?: Amity.User[]
+      files?: Amity.File[]
+    }
+
+    type CategoryPayload = {
+      categories: Amity.Category[]
+      files: Amity.File[]
+    }
+
+    type CommunityMembershipPayload = {
+      communities?: Amity.Community[]
+      communityUsers: Amity.Membership<'community'>[]
+      categories?: Amity.Category[]
+      feeds?: Amity.Feed[]
+      users?: Amity.User[]
+      files?: Amity.File[]
+    }
+
+    type PostPayload<T extends Amity.PostContentType = any> = {
+      posts: Amity.Post<T>[]
+      postChildren?: Amity.Post[]
+      communities?: Amity.Community[]
+      communityUsers?: Amity.Membership<'community'>[]
+      categories?: Amity.Category[]
+      comments?: Amity.Comment[]
+      feeds?: Amity.Feed[]
+      users?: Amity.User[]
+      files?: Amity.File[]
+    }
+
+    type CommentPayload<T extends Amity.CommentContentType = any> = {
+      comments: Amity.Comment<T>[]
+      commentChildren?: Amity.Comment[]
+      users?: Amity.User[]
+      files?: Amity.File[]
+    }
+
+    type GlobalFeedPayload = Amity.PostPayload
+  }
+}