@amityco/ts-sdk-react-native 6.7.1-80c1951.0

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

@@ -0,0 +1,330 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type Payloads = {
+      user: Amity.UserPayload;
+      file: Amity.FilePayload;
+      role: Amity.RolePayload;
+      channel: Amity.ChannelPayload;
+      subChannel: Amity.SubChannelPayload;
+      channelUser: Amity.ChannelMembershipPayload;
+      message: Amity.MessagePayload;
+      community: Amity.CommunityPayload;
+      category: Amity.CategoryPayload;
+      communityUser: Amity.CommunityMembershipPayload;
+      post: Amity.PostPayload;
+      comment: Amity.CommentPayload;
+      poll: Amity.PollPayload;
+      stream: Amity.StreamPayload;
+      reaction: Amity.ReactionPayload;
+    };
+
+    type UserPayload = {
+      users: Amity.User[];
+      files: Amity.File<'image'>[];
+    };
+
+    type FeedSettingPayload = {
+      feedSettings: {
+        contentSettings: Amity.ContentSetting[];
+        feedType: Amity.ContentFeedType;
+      }[];
+    };
+
+    // 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.RawChannel<T>[];
+      channelUsers: Amity.RawMembership<'channel'>[];
+    } & Amity.UserPayload;
+
+    /**
+     * Items that extend from `Amity.Channel`
+     * - channels: `Amity.RawChannel` -> `Amity.Channel` (Added Marker Service related props)
+     * - channelUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedChannelPayload<T extends Amity.ChannelType = any> = Omit<
+      ChannelPayload,
+      'channels' | 'channelUsers'
+    > & {
+      channels: Amity.Channel<T>[];
+      channelUsers: Amity.Membership<'channel'>[];
+    };
+
+    type UserMarkerPayload = {
+      userMarkers: Amity.UserMarker[];
+    };
+
+    type ChannelMarkerPayload = {
+      userEntityMarkers: Amity.ChannelMarker[];
+      userMarkers: Amity.UserMarker[];
+    };
+
+    type SubChannelMarkerPayload = {
+      userFeedMarkers: Amity.SubChannelMarker[];
+      userEntityMarkers: Amity.ChannelMarker[];
+      userMarkers: Amity.UserMarker[];
+    };
+
+    type MessageMarkerPayload = {
+      contentMarkers: Amity.MessageMarker[];
+      feedMarkers: Amity.FeedMarker[];
+      userMarkers: Amity.UserMarker[];
+    };
+
+    type MarkReadPayload = {
+      userMarkers: Amity.UserMarker[];
+      userEntityMarkers: Amity.ChannelMarker[];
+      userFeedMarkers: Amity.SubChannelMarker[];
+      feedMarkers: Amity.MessageMarker[];
+    };
+
+    type MarkerSyncPayload = {
+      userMarkers: Amity.UserMarker[];
+      userEntityMarkers: Amity.ChannelMarker[];
+      userFeedMarkers: Amity.SubChannelMarker[];
+      feedMarkers: Amity.FeedMarker[];
+    };
+
+    type MarkAsReadPayload = {
+      userMarkers: Amity.UserMarker[];
+      userEntityMarkers: Amity.ChannelMarker[];
+      userFeedMarkers: Amity.SubChannelMarker[];
+      feedMarkers: Amity.FeedMarker[];
+    };
+
+    type MarkDeliveredPayload = {
+      userMarkers: Amity.UserMarker[];
+      userEntityMarkers: Amity.ChannelMarker[];
+      userFeedMarkers: Amity.SubChannelMarker[];
+      feedMarkers: Amity.FeedMarker[];
+    };
+
+    type ReadUserPayload = {
+      contentMarkers: Amity.MessageMarker[];
+      feedMarkers: Amity.FeedMarker[];
+      userFeedMarker: Amity.SubChannelMarker[];
+      publicUserIds: Amity.User['userId'][];
+    };
+
+    type DeliveredUserPayload = {
+      contentMarkers: Amity.MessageMarker[];
+      feedMarkers: Amity.FeedMarker[];
+      userFeedMarker: Amity.SubChannelMarker[];
+      publicUserIds: Amity.User['userId'][];
+    };
+
+    type StartReadingPayload = {
+      userMarkers: Amity.UserMarker[];
+      userEntityMarkers: Amity.ChannelMarker[];
+      userFeedMarkers: Amity.SubChannelMarker[];
+      feedMarkers: Amity.FeedMarker[];
+    };
+
+    type ReadingPayload = {
+      userMarkers: Amity.UserMarker[];
+      userEntityMarkers: Amity.ChannelMarker[];
+      userFeedMarkers: Amity.SubChannelMarker[];
+      feedMarkers: Amity.FeedMarker[];
+    };
+
+    type StopReadingPayload = {
+      userMarkers: Amity.UserMarker[];
+      userEntityMarkers: Amity.ChannelMarker[];
+      userFeedMarkers: Amity.SubChannelMarker[];
+      feedMarkers: Amity.FeedMarker[];
+    };
+
+    type MarkedMessagePayload = {
+      contentMarkers: Amity.MessageMarker[];
+      feedMarkers: Amity.FeedMarker[];
+    };
+
+    type FeedUpdatedPayload = {
+      contentMarkers: Amity.MessageMarker[];
+      feedMarkers: Amity.FeedMarker[];
+    };
+
+    type UserMarkerSyncPayload = {
+      userMarkers: Amity.UserMarker[];
+      userEntityMarkers: Amity.ChannelMarker[];
+      userFeedMarker: Amity.SubChannelMarker[];
+    };
+
+    type SubChannelPayload<T extends Amity.MessageContentType = any> = {
+      messageFeeds: Amity.RawSubChannel[];
+      messages: Amity.RawMessage<T>[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    /**
+     * Items that extend from `Amity.SubChannelPayload`
+     * - messageFeeds: `Amity.RawSubChannel` -> `Amity.SubChannel` (Model Restructuring)
+     * - messages: `Amity.RawMessage` -> `Amity.Message` (Model Restructuring)
+     */
+    type ProcessedSubChannelPayload<T extends Amity.MessageContentType = any> = {
+      messageFeeds: Amity.SubChannel[];
+      messages: Amity.Message<T>[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    type ChannelMembershipPayload = {
+      channels: Amity.RawChannel[];
+      channelUsers: Amity.RawMembership<'channel'>[];
+    } & Amity.UserPayload;
+
+    /**
+     * Items that extend from `Amity.ChannelMembershipPayload`
+     * - channels: `Amity.RawChannel` -> `Amity.Channel` (Added Marker Service related props)
+     * - channelUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedChannelMembershipPayload = Omit<
+      ChannelMembershipPayload,
+      'channels' | 'channelUsers'
+    > & {
+      channels: Amity.Channel[];
+      channelUsers: Amity.Membership<'channel'>[];
+    };
+
+    /**
+     * Items that extend from `Amity.MessagePayload`
+     * - messages: `Amity.RawMessage` -> `Amity.Message` (Model Restructuring)
+     */
+    type ProcessedMessagePayload<T extends Amity.MessageContentType = any> = {
+      messages: Amity.Message<T>[];
+      users: Amity.User[];
+      files: Amity.File[];
+      reactions: Amity.Reactor[];
+    };
+
+    type MessagePayload<T extends Amity.MessageContentType = any> = Omit<
+      ProcessedMessagePayload<T>,
+      'messages'
+    > & {
+      messages: Amity.RawMessage<T>[];
+    };
+
+    type StreamPayload = {
+      videoStreamings: Amity.Stream[];
+      users: Amity.User[];
+      files: Amity.File<'image'>[];
+    };
+
+    type CommunityPayload = {
+      communities: Amity.RawCommunity[];
+      communityUsers: Amity.RawMembership<'community'>[];
+      categories: Amity.Category[];
+      feeds: Amity.Feed[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    /**
+     * Items that extend from `Amity.CommunityPayload`
+     * - communities: `Amity.RawCommunity` -> `Amity.Community` (Added Marker Service related props)
+     * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedCommunityPayload = Omit<CommunityPayload, 'communities' | 'communityUsers'> & {
+      communities: Amity.Community[];
+      communityUsers: Amity.Membership<'community'>[];
+    };
+
+    type CategoryPayload = {
+      categories: Amity.Category[];
+      files: Amity.File[];
+    };
+
+    type CommunityMembershipPayload = {
+      communities: Amity.RawCommunity[];
+      communityUsers: Amity.RawMembership<'community'>[];
+      categories: Amity.Category[];
+      feeds: Amity.Feed[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    /**
+     * Items that extend from `Amity.CommunityMembershipPayload`
+     * - communities: `Amity.RawCommunity` -> `Amity.Community` (Added Marker Service related props)
+     * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedCommunityMembershipPayload = Omit<
+      CommunityMembershipPayload,
+      'communities' | 'communityUsers'
+    > & {
+      communities: Amity.Community[];
+      communityUsers: Amity.Membership<'community'>[];
+    };
+
+    type PostPayload<T extends Amity.PostContentType = any> = {
+      posts: Amity.Post<T>[];
+      postChildren: Amity.Post[];
+      communities: Amity.RawCommunity[];
+      communityUsers: Amity.RawMembership<'community'>[];
+      categories: Amity.Category[];
+      comments: Amity.Comment[];
+      feeds: Amity.Feed[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    /**
+     * Items that extend from `Amity.PostPayload`
+     * - communities: `Amity.RawCommunity` -> `Amity.Community` (Added Marker Service related props)
+     * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedPostPayload = Omit<PostPayload, 'communities' | 'communityUsers'> & {
+      communities: Amity.Community[];
+      communityUsers: Amity.Membership<'community'>[];
+    };
+
+    type CommentPayload<T extends Amity.CommentContentType = any> = {
+      comments: Amity.Comment<T>[];
+      commentChildren: Amity.Comment[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    type PollPayload = {
+      users: Amity.User[];
+      polls: Amity.Poll[];
+    };
+
+    type ReactionPayload = {
+      reactions: Amity.Reaction[];
+      users: Amity.User[];
+    };
+
+    type GlobalFeedPayload = Amity.PostPayload;
+
+    type FollowStatusPayload = {
+      follows: Amity.FollowStatus[];
+    };
+
+    type FollowInfoMePayload = {
+      followCounts: Amity.FollowCount[];
+    };
+
+    type FollowersPayload = Amity.FollowStatusPayload & UserPayload;
+
+    type FollowInfoPayload = FollowInfoMePayload & Amity.FollowStatusPayload;
+
+    type BlockedPayload = {
+      follows: Amity.FollowStatusPayload['follows'];
+      followCounts: Amity.FollowCount[];
+    };
+
+    type BlockedUserPayload = Amity.FollowStatusPayload[] &
+      Amity.UserPayload &
+      Amity.BlockedUserPaged;
+  }
+}

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

@@ -0,0 +1,74 @@
+export {};
+
+declare global {
+  namespace Amity {
+    const enum Permission {
+      EditUserPermission = 'EDIT_USER',
+      BanUserPermission = 'BAN_USER',
+      CreateRolePermission = 'CREATE_ROLE',
+      EditRolePermission = 'EDIT_ROLE',
+      DeleteRolePermission = 'DELETE_ROLE',
+      AssignRolePermission = 'ASSIGN_USER_ROLE',
+      EditChannelPermission = 'EDIT_CHANNEL',
+      EditChannelRatelimitPermission = 'EDIT_CHANNEL_RATELIMIT',
+      MuteChannelPermission = 'MUTE_CHANNEL',
+      CloseChannelPermission = 'CLOSE_CHANNEL',
+      AddChannelUserPermission = 'ADD_CHANNEL_USER',
+      EditChannelUserPermission = 'EDIT_CHANNEL_USER',
+      RemoveChannelUserPermission = 'REMOVE_CHANNEL_USER',
+      MuteChannelUserPermission = 'MUTE_CHANNEL_USER',
+      BanChannelUserPermission = 'BAN_CHANNEL_USER',
+      EditMessagePermission = 'EDIT_MESSAGE',
+      DeleteMessagePermission = 'DELETE_MESSAGE',
+      EditCommunityPermission = 'EDIT_COMMUNITY',
+      DeleteCommunityPermission = 'DELETE_COMMUNITY',
+      AddChannelCommunityPermission = 'ADD_COMMUNITY_USER',
+      EditChannelCommunityPermission = 'EDIT_COMMUNITY_USER',
+      RemoveChannelCommunityPermission = 'REMOVE_COMMUNITY_USER',
+      MuteChannelCommunityPermission = 'MUTE_COMMUNITY_USER',
+      BanChannelCommunityPermission = 'BAN_COMMUNITY_USER',
+      EditUserFeedPostPermission = 'EDIT_USER_FEED_POST',
+      DeleteUserFeedPostPermission = 'DELETE_USER_FEED_POST',
+      EditUserFeedCommentPermission = 'EDIT_USER_FEED_COMMENT',
+      DeleteUserFeedCommentPermission = 'DELETE_USER_FEED_COMMENT',
+      EditCommunityFeedPostPermission = 'EDIT_COMMUNITY_FEED_POST',
+      DeleteCommunityFeedPostPermission = 'DELETE_COMMUNITY_FEED_POST',
+      EditCommunityFeedCommentPermission = 'EDIT_COMMUNITY_FEED_COMMENT',
+      DeleteCommunityFeedCommentPermission = 'DELETE_COMMUNITY_FEED_COMMENT',
+      CreateCommunityCategoryPermission = 'CREATE_COMMUNITY_CATEGORY',
+      EditCommunityCategoryPermission = 'EDIT_COMMUNITY_CATEGORY',
+      DeleteCommunityCategoryPermission = 'DELETE_COMMUNITY_CATEGORY',
+    }
+
+    const enum PermissionLegacy {
+      ModeratorRoleLegacy = 'moderator',
+      SuperModeratorRoleLegacy = 'super-moderator',
+      GlobalAdminRoleLegacy = 'global-admin',
+      BanUserPermissionLegacy = 'Channel/BanUser',
+      MuteUserPermissionLegacy = 'Channel/MuteUser',
+      MuteChannelPermissionLegacy = 'Channel/MuteChannel',
+      RateLimitUserPermissionLegacy = 'Channel/RateLimitUser',
+      RateLimitChannelPermissionLegacy = 'Channel/RateLimitChannel',
+      ManageMessagesPermissionLegacy = 'Channel/ManageMessages',
+      ManageUsersPermissionLegacy = 'Channel/ManageUsers',
+      GlobalAccessPermissionLegacy = 'Channel/GlobalAccess',
+      ExemptFromFiltersPermissionLegacy = 'User/ExemptFromFilters',
+      ExemptFromRateLimitsPermissionLegacy = 'User/ExemptFromRateLimits',
+      ExemptFromMutePermissionLegacy = 'User/ExemptFromMute',
+      ExemptFromBanPermissionLegacy = 'User/ExempFromBan',
+      ExemptFromWhitelistPermissionLegacy = 'User/ExempFromWhitelist',
+      ExemptFromBlacklistPermissionLegacy = 'User/ExempFromBlacklist',
+      ExemptFromRepetitionCheckPermissionLegacy = 'User/ExempFromRepetitionCheck',
+      ManagePostsPermissionLegacy = 'Post/ManagePosts',
+      ManageCommentsPermissionLegacy = 'Post/ManageComments',
+      ManageCommunitiesPermissionLegacy = 'Community/ManageCommunities',
+    }
+
+    type Role = {
+      roleId: string;
+      displayName: string;
+      permissions: Permission[];
+    } & Amity.Timestamps &
+      Amity.SoftDelete;
+  }
+}

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

@@ -0,0 +1,63 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type Cachable = {
+      cachedAt: number;
+    };
+
+    type Local = {
+      cachedAt: -1;
+    };
+
+    type AsyncFunc<Args extends any[], Returned extends any> = {
+      (...args: Args): Promise<Returned>;
+    };
+
+    type FetcherFunc<Args extends any[], Returned extends any> = {
+      (...args: Args): Promise<Returned>;
+      locally: (...args: Args) => Returned | undefined;
+    };
+
+    type MutatorFunc<Args extends any[], Returned extends any> = {
+      (...args: Args): Promise<Returned>;
+      optimistically: (...args: Args) => Returned | undefined;
+    };
+
+    type OfflineFunc<Args extends any[], Returned extends any> =
+      | FetcherFunc<Args, Returned>
+      | MutatorFunc<Args, Returned>;
+
+    type Query<Args extends any[], Returned extends any> = {
+      func: AsyncFunc<Args, Returned> | OfflineFunc<Args, Returned>;
+      args: Args;
+    };
+
+    type QueryPolicy = 'cache_only' | 'cache_then_server' | 'no_fetch';
+
+    type QueryOptions = {
+      lifeSpan: number;
+    };
+
+    type SnapshotOptions = {
+      origin: 'local' | 'server' | 'event';
+      loading: boolean;
+      error?: any;
+    };
+
+    type Snapshot<T> = (T extends Amity.Cached<infer T2>
+      ? T2 extends Amity.Paged<infer T3, infer T4>
+        ? { data: T3[] | undefined } & Amity.Pages<T4> & {
+              cachedAt?: Amity.CacheOptions['cachedAt'];
+            }
+        : { data: T2 } & { cachedAt?: Amity.CacheOptions['cachedAt'] }
+      : T extends Amity.Paged<infer T3, infer T4>
+      ? { data: T3[] | undefined } & Amity.Pages<T4>
+      : { data: T | undefined }) &
+      SnapshotOptions;
+
+    type RunQueryOptions<T> = T extends Amity.AsyncFunc<infer Args, infer Returned>
+      ? Omit<Amity.Snapshot<Returned>, 'data'>
+      : never;
+  }
+}

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

@@ -0,0 +1,55 @@
+import { ASCError } from '~/core/errors';
+
+export {};
+
+declare global {
+  namespace Amity {
+    type SuccessResponse<T> = {
+      status: 'success';
+      data: T;
+    };
+
+    type FailResponse = {
+      status: 'fail';
+      code: Amity.ServerError;
+    };
+
+    type ErrorResponse = {
+      status: 'error';
+      message: string;
+      code: Amity.ServerError;
+    };
+
+    type Response<T> = SuccessResponse<T> | FailResponse | ErrorResponse;
+
+    type Token = string;
+
+    type Pagination = {
+      paging: {
+        previous?: Token;
+        next?: Token;
+      };
+    };
+
+    type MqttClient = {
+      connect: (params: { accessToken: string; userId: string }) => Promise<void>;
+      disconnect: () => Promise<void>;
+      get connected(): boolean;
+      on: <T extends keyof Amity.MqttEvents>(
+        event: T,
+        handler: (payload: Amity.MqttEvents[T]) => void,
+      ) => void;
+      once: <T extends keyof Amity.MqttEvents>(
+        event: T,
+        handler: (payload: Amity.MqttEvents[T]) => void,
+      ) => void;
+      off: <T extends keyof Amity.MqttEvents>(
+        event: T,
+        handler?: (payload: Amity.MqttEvents[T]) => void,
+      ) => void;
+      removeAllListeners: () => void;
+      subscribe: (topic: string, callback?: Amity.Listener<ASCError | void>) => Amity.Unsubscriber;
+      unsubscribe: (topic: string) => void;
+    };
+  }
+}

package/src/@types/domains/block.ts

@@ -0,0 +1,24 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type QueryBlockedUser = {
+      token?: Amity.Token;
+      limit?: Amity.PageLimit['limit'];
+    };
+
+    type BlockedUserPaged = {
+      paging: Amity.Pagination['paging'] & { total: number };
+    };
+
+    type BlockedUsersLiveCollection = Amity.LiveCollectionParams<QueryBlockedUser>;
+
+    type BlockedUserLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.User['userId'],
+      {
+        page: Amity.Page;
+        total: number;
+      }
+    >;
+  }
+}

package/src/@types/domains/category.ts

@@ -0,0 +1,26 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type Category = {
+      categoryId: string;
+      name: string;
+      avatarFileId?: Amity.File<'image'>['fileId'];
+    } & Amity.Metadata &
+      Amity.Timestamps &
+      Amity.SoftDelete;
+
+    type QueryCategories = {
+      includeDeleted?: boolean;
+      sortBy?: 'name' | 'firstCreated' | 'lastCreated';
+      page?: Amity.Page;
+    };
+
+    type CategoryLiveCollection = Amity.LiveCollectionParams<Omit<QueryCategories, 'page'>>;
+
+    type CategoryLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Category['categoryId'],
+      Pick<QueryCategories, 'page'>
+    >;
+  }
+}

package/src/@types/domains/channel.ts

@@ -0,0 +1,115 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type ChannelType = 'broadcast' | 'conversation' | 'community' | 'live';
+
+    type ChannelMemberActionType =
+      | 'onJoin'
+      | 'onLeft'
+      | 'onMemberRead'
+      | 'onMemberAdded'
+      | 'onMemberRemoved'
+      | 'onChannelMemberBanned'
+      | 'onChannelMemberUnbanned';
+
+    type ChannelActionType =
+      | 'onFetch'
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onJoin'
+      | 'onLeft'
+      | 'onMute'
+      | 'onMemberAdded'
+      | 'onMemberRemoved';
+
+    type RawChannel<T extends ChannelType = any> = {
+      _id: string;
+      channelId: string;
+      displayName?: string;
+      avatarFileId?: Amity.File<'image'>['fileId'];
+      type: T;
+
+      isDistinct?: boolean;
+
+      isMuted?: boolean;
+      muteTimeout?: string;
+
+      isRateLimited?: boolean;
+      rateLimit?: number;
+      rateLimitWindow?: number;
+      rateLimitTimeout?: number;
+
+      messageAutoDeleteEnabled?: boolean;
+      autoDeleteMessageByFlagLimit?: number;
+
+      memberCount?: number;
+      messageCount: number;
+      moderatorMemberCount?: number;
+
+      lastActivity: Amity.timestamp;
+    } & Amity.Metadata &
+      Amity.Taggable &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable;
+
+    type Channel<T extends ChannelType = any> = Omit<RawChannel<T>, 'messageCount'> & {
+      defaultSubChannelId: string;
+      isUnreadCountSupport: boolean;
+      unreadCount: number;
+
+      /**
+       * @deprecated Please use the default sub channel `messageCount` instead.
+       */
+      messageCount: RawChannel['messageCount'];
+    };
+
+    type QueryChannels = {
+      displayName?: string;
+      membership?: 'all' | 'member' | 'notMember';
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated' | 'lastActivity';
+      types?: Amity.ChannelType[];
+      isDeleted?: Amity.Channel['isDeleted'];
+      tags?: Amity.Taggable['tags'];
+      excludeTags?: Amity.Taggable['tags'];
+      page?: Amity.Page;
+    };
+
+    type ChannelLiveCollection = Amity.LiveCollectionParams<Omit<QueryChannels, 'page'>>;
+
+    type ChannelLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Channel['channelId'],
+      Pick<QueryChannels, 'page'>
+    >;
+
+    type QueryChannelMembers = {
+      channelId: Amity.Channel['channelId'];
+      memberships?: Array<Exclude<Amity.Membership<'channel'>['membership'], 'none'> | 'muted'>;
+      roles?: string[];
+      sortBy?: 'firstCreated' | 'lastCreated';
+      search?: string;
+      page?: Amity.Page;
+    };
+
+    type SearchChannelMembers = Amity.LiveCollectionParams<Omit<QueryChannelMembers, 'sortBy'>>;
+
+    type ChannelMembersLiveCollection = Amity.LiveCollectionParams<
+      Omit<
+        QueryChannelMembers,
+        'page'
+        /**
+         * @remarks
+         * search will be deprecated in the next major version, please use `searchMembers()` instead.
+         *  | 'search'
+         */
+      >
+    >;
+
+    type ChannelMembersLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Membership<'channel'>['userId'],
+      Pick<QueryChannelMembers, 'page'>
+    >;
+  }
+}