@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

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

@@ -1,74 +0,0 @@
-export {};
-
-declare global {
-  namespace Amity {
-    /**
-     * Union of acceptable types for a chunk of cache key.
-     * Recursive type which allow 3 primitives + array or object of them.
-     *
-     * @hidden
-     */
-    type Serializable =
-      | string
-      | number
-      | boolean
-      | undefined
-      | Serializable[]
-      | { [key: string]: Serializable };
-
-    /**
-     * Cache key description. Similarly to react-query,
-     * the key is an array of serializable values.
-     */
-    type CacheKey = Serializable[];
-
-    /**
-     * Cache options are separated from CacheEntry for further type
-     * manipulations and passing of options in functions.
-     *
-     * The cache options are:
-     *   - cachedAt(number): used to check is the cached content is still
-     *     considered fresh or not.
-     *
-     *   - offline(boolean): used to determine if the entry must be
-     *     saved in persistent storage on top of the regular caching.
-     */
-    type CacheOptions = {
-      cachedAt: number | undefined;
-      offline?: boolean;
-    };
-
-    type TombstoneCacheOptions = {
-      cachedAt: number;
-    };
-
-    /**
-     * Cache entry wrapper. It contains the cached content
-     * itself (data: T) and also several other properties
-     * through CacheOptions to allow fine tuned control.
-     */
-    type CacheEntry<T extends unknown = unknown> = {
-      key: CacheKey;
-      data: T;
-    } & CacheOptions;
-
-    /**
-     * Minimal CacheEntry alias, used mostly
-     */
-    type Cached<T extends unknown = unknown> = (T extends Amity.Paged<any, infer K>
-      ? T
-      : { data: T }) & {
-      cachedAt: CacheOptions['cachedAt'];
-    };
-
-    /**
-     * Main interface for the cache data structure. There's no direct
-     * methods there as we want to keep the object easily serializable
-     * (over JSON.stringify/parse) for simple backup/hydration.
-     */
-    type Cache = {
-      data: Record<string, CacheEntry>;
-      persistIf?: (key: CacheKey, data?: any) => boolean;
-    };
-  }
-}

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

@@ -1,42 +0,0 @@
-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,
-      CHANNEL_IS_MUTED = 400303,
-      CHANNEL_BAN = 400304,
-      GLOBAL_BAN = 400312,
-      NUMBER_OF_MEMBERS_EXCEEDED = 400305,
-      MAX_REPETITION_EXCEEDED = 400307,
-      BAN_WORD_FOUND = 400308,
-      LINK_NOT_ALLOWED = 400309,
-      BUSINESS_ERROR = 500000,
-      VISITOR_PERMISSION_DENIED = 403999,
-      BOT_PERMISSION_DENIED = 403998,
-    }
-
-    const enum ClientError {
-      UNKNOWN_ERROR = 800000,
-      INVALID_PARAMETERS = 800110,
-      QUERY_IN_PROGRESS = 800170,
-      CONNECTION_ERROR = 800210,
-      DISCONNECTED = 800211,
-      TOKEN_EXPIRED = 800403,
-      DISALOOW_UNSYNCED_OBJECT = 800800,
-    }
-
-    type ErrorCode = ServerError | ClientError;
-  }
-}

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

@@ -1,294 +0,0 @@
-/* eslint-disable camelcase */
-import { IConnectPacket, IDisconnectPacket, IPublishPacket } from 'mqtt/dist/mqtt';
-
-export {};
-
-declare global {
-  namespace Amity {
-    type Listener<T = any> = (params: T) => any;
-
-    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 WsEvents = {
-      disconnected: Amity.ErrorResponse | undefined;
-      error: Amity.ErrorResponse | undefined;
-      connect_error: Amity.ErrorResponse | undefined;
-      reconnect_error: Amity.ErrorResponse | undefined;
-      reconnect_failed: Amity.ErrorResponse | undefined;
-    };
-
-    type MqttEvents = {
-      connect: IConnectPacket;
-      message: [topic: string, payload: Buffer, packet: IPublishPacket];
-      disconnect: IDisconnectPacket;
-      error: Error;
-      close: Error;
-      end: undefined;
-      reconnect: undefined;
-
-      'video-streaming.didStart': Amity.StreamPayload;
-      'video-streaming.didRecord': Amity.StreamPayload;
-      'video-streaming.didStop': Amity.StreamPayload;
-      'video-streaming.didFlag': Amity.StreamPayload;
-      'video-streaming.didTerminate': Amity.StreamPayload;
-
-      'video-streaming.viewerDidBan': Amity.StreamViewerBanPayload;
-      'video-streaming.viewerDidUnban': Amity.StreamViewerUnbanPayload;
-
-      'user.didGlobalBan': Amity.UserPayload;
-
-      'liveReaction.created': Amity.LiveReactionPayload;
-    };
-
-    type MqttChannelUserEvents = {
-      'channel.joined': Amity.ChannelMembershipPayload;
-      'channel.left': Amity.ChannelMembershipPayload;
-      'channel.membersAdded': Amity.ChannelMembershipPayload;
-      'channel.membersRemoved': Amity.ChannelMembershipPayload;
-      'channel.banned': Amity.ChannelMembershipPayload;
-      'channel.unbanned': Amity.ChannelMembershipPayload;
-    };
-
-    type MqttChannelEvents = {
-      'channel.created': Amity.ChannelPayload;
-      'channel.updated': Amity.ChannelPayload;
-      'channel.deleted': Amity.ChannelPayload;
-      'channel.setMuted': Amity.ChannelSetMutedPayload;
-      'channel.setMutedUsers': Amity.ChannelSetUserMutedPayload;
-    } & MqttChannelUserEvents;
-
-    type MqttSubChannelEvents = {
-      'message-feed.created': Amity.SubChannelPayload;
-      'message-feed.updated': Amity.SubChannelPayload;
-      'message-feed.deleted': Amity.SubChannelPayload;
-    };
-
-    type MqttMessageEvents = {
-      'message.created': Amity.MessagePayload;
-      'message.updated': Amity.MessagePayload;
-      'message.deleted': Amity.MessagePayload;
-      'message.flagged': Amity.MessagePayload;
-      'message.unflagged': Amity.MessagePayload;
-      'message.flagCleared': Amity.MessagePayload;
-      'message.reactionAdded': Amity.MessagePayload;
-      'message.reactionRemoved': Amity.MessagePayload;
-    };
-
-    type MqttStoryEvents = {
-      'story.created': Amity.StoryPayload;
-      'story.updated': Amity.StoryPayload;
-      'story.deleted': Amity.StoryPayload;
-      'story.flagged': Amity.StoryPayload;
-      'story.unflagged': Amity.StoryPayload;
-      'story.reactionAdded': Amity.StoryReactionPayload;
-      'story.reactionRemoved': Amity.StoryReactionPayload;
-    };
-
-    type MqttCommunityUserEvents = {
-      'community.joined': Amity.CommunityMembershipPayload;
-      'community.left': Amity.CommunityMembershipPayload;
-      'community.userAdded': Amity.CommunityMembershipPayload;
-      'community.userRemoved': Amity.CommunityMembershipPayload;
-      'community.userChanged': Amity.CommunityMembershipPayload;
-      'community.userBanned': Amity.CommunityMembershipPayload;
-      'community.userUnbanned': Amity.CommunityMembershipPayload;
-      'community.roleAdded': Amity.CommunityMembershipPayload;
-      'community.roleRemoved': Amity.CommunityMembershipPayload;
-    };
-
-    type MqttCommunityEvents = {
-      'community.created': Amity.CommunityPayload;
-      'community.updated': Amity.CommunityPayload;
-      'community.deleted': Amity.CommunityPayload;
-    } & MqttCommunityUserEvents;
-
-    type MqttPostEvents = {
-      'post.created': Amity.PostPayload;
-      'post.updated': Amity.PostPayload;
-      'post.deleted': Amity.PostPayload;
-      'post.approved': Amity.PostPayload;
-      'post.declined': Amity.PostPayload;
-      'post.flagged': Amity.PostPayload;
-      'post.unflagged': Amity.PostPayload;
-      'post.addReaction': Amity.PostPayload & { reactor: Amity.InternalReactor };
-      'post.removeReaction': Amity.PostPayload & { reactor: Amity.InternalReactor };
-    };
-
-    type MqttCommentEvents = {
-      'comment.created': Amity.CommentPayload;
-      'comment.updated': Amity.CommentPayload;
-      'comment.deleted': Amity.CommentPayload;
-      'comment.flagged': Amity.CommentPayload;
-      'comment.unflagged': Amity.CommentPayload;
-      'comment.addReaction': Amity.CommentPayload & { reactor: Amity.InternalReactor };
-      'comment.removeReaction': Amity.CommentPayload & { reactor: Amity.InternalReactor };
-    };
-
-    type MqttUserEvents = {
-      'user.fetched': Amity.UserPayload;
-      'user.updated': Amity.UserPayload;
-      'user.deleted': Amity.UserPayload; // received from network topic
-      'user.flagged': Amity.UserPayload;
-      'user.unflagged': Amity.UserPayload;
-      'user.flagCleared': Amity.UserPayload;
-    };
-
-    type MqttFollowEvents = {
-      'follow.created': Amity.FollowersPayload;
-      'follow.requested': Amity.FollowersPayload;
-      'follow.accepted': Amity.FollowersPayload;
-      'follow.unfollowed': Amity.FollowersPayload;
-      'follow.requestCanceled': Amity.FollowersPayload;
-      'follow.requestDeclined': Amity.FollowersPayload;
-      'follow.followerDeleted': Amity.FollowersPayload;
-    };
-
-    type MqttMarkerEvents = {
-      'marker.marked-message': Amity.MarkedMessagePayload;
-      'marker.feed-updated': Amity.FeedUpdatedPayload;
-      'marker.user-sync': Amity.UserMarkerSyncPayload;
-      'marker.userFeed-updated': Amity.UserFeedUpdatedPayload;
-    };
-
-    type MqttRTE = MqttChannelEvents &
-      MqttSubChannelEvents &
-      MqttMessageEvents &
-      MqttCommunityEvents &
-      MqttPostEvents &
-      MqttCommentEvents &
-      MqttUserEvents &
-      MqttFollowEvents &
-      MqttMarkerEvents &
-      MqttStoryEvents;
-
-    type LocalPostEvents = {
-      'local.post.updated': Amity.PostPayload;
-      'local.post.deleted': Amity.PostPayload;
-      'local.post.addReaction': { post: Amity.InternalPost } & { reactor: Amity.InternalReactor };
-      'local.post.removeReaction': {
-        post: Amity.InternalPost;
-        reactor: Amity.InternalReactor;
-      };
-    };
-
-    type LocalCommentEvents = {
-      'local.comment.created': Amity.CommentPayload;
-      'local.comment.deleted': Amity.CommentPayload;
-      'local.comment.addReaction': { comment: Amity.InternalComment } & {
-        reactor: Amity.InternalReactor;
-      };
-      'local.comment.removeReaction': {
-        comment: Amity.InternalComment;
-        reactor: Amity.InternalReactor;
-      };
-    };
-
-    type LocalCommunityEvents = {
-      'local.community.joined': Amity.CommunityMembershipPayload;
-      'local.community.left': Amity.CommunityMembershipPayload;
-      'local.community.roleAdded': Amity.ProcessedCommunityPayload;
-      'local.community.roleRemoved': Amity.ProcessedCommunityPayload;
-      'local.community.userAdded': Amity.CommunityMembershipPayload;
-      'local.community.userRemoved': Amity.CommunityMembershipPayload;
-    };
-
-    type LocalFollowEvents = {
-      'local.follow.created': Amity.FollowStatusPayload;
-      'local.follow.requested': Amity.FollowStatusPayload;
-      'local.follow.accepted': Amity.FollowStatusPayload;
-      'local.follow.unfollowed': Amity.FollowStatusPayload;
-      'local.follow.requestDeclined': Amity.FollowStatusPayload;
-    };
-
-    type LocalEvents = {
-      'local.channel.updated': MakeRequired<Amity.ProcessedChannelPayload, 'channels'>;
-      'local.channel.fetched': Amity.StaticInternalChannel[];
-      'local.channel-moderator.role-added': Amity.ProcessedChannelPayload;
-      'local.channel-moderator.role-removed': Amity.ProcessedChannelPayload;
-      'local.message.created': MakeRequired<Amity.ProcessedMessagePayload, 'messages'>;
-      'local.message.updated': MakeRequired<Amity.ProcessedMessagePayload, 'messages'>;
-      'local.message.deleted': MakeRequired<Amity.ProcessedMessagePayload, 'messages'>;
-      'local.message.fetched': MakeRequired<Amity.ProcessedMessagePayload, 'messages'>;
-      'local.message-feed.updated': MakeRequired<Amity.ProcessedSubChannelPayload, 'messageFeeds'>;
-      'local.message-feed.fetched': MakeRequired<Amity.ProcessedSubChannelPayload, 'messageFeeds'>;
-      'local.message-feed.deleted': MakeRequired<Amity.ProcessedSubChannelPayload, 'messageFeeds'>;
-      'poll.updated': MakeRequired<Amity.PollPayload, 'polls'>;
-      'poll.deleted': MakeRequired<Amity.PollPayload, 'polls'>;
-      'local.feedMarker.fetched': { feedMarkers: Amity.FeedMarker[] };
-      'local.channelMarker.fetched': { userEntityMarkers: Amity.ChannelMarker[] };
-      'local.channelMarker.updated': { userEntityMarkers: Amity.ChannelMarker[] };
-      'local.subChannelMarker.fetched': { userFeedMarkers: Amity.SubChannelMarker[] };
-      'local.subChannelMarker.updated': { userFeedMarkers: Amity.SubChannelMarker[] };
-      'local.messageMarker.fetched': MakeRequired<Amity.MessageMarkerPayload, 'contentMarkers'>;
-      'local.userMarker.fetched': { userMarkers: Amity.UserMarker[] };
-
-      'local.userMessageFeedMarker.fetched': {
-        userMessageFeedMarker: Amity.UserMessageFeedMarkerPayload;
-      };
-
-      'local.channel.resolved': Amity.StaticInternalChannel[];
-      'local.userMessageFeedMarkers.resolved': {
-        feedMarkers: Amity.FeedMarker[];
-        userFeedMarkers: Amity.UserFeedMarkerResponse[];
-      };
-
-      'local.subChannelUnread.updated': Amity.SubChannelUnreadInfo;
-      'local.channelUnreadInfo.updated': Amity.ChannelUnreadInfo;
-      'local.channelUnread.updated': Amity.ChannelUnread[];
-
-      'local.story.created': Amity.StoryPayload;
-      'local.story.updated': Amity.StoryPayload;
-      'local.story.deleted': Amity.StoryPayload;
-
-      'local.story.flagged': Amity.StoryPayload;
-      'local.story.unflagged': Amity.StoryPayload;
-      'local.story.reactionAdded': { story: Amity.InternalStory } & {
-        reactor: Amity.InternalReactor;
-      };
-      'local.story.reactionRemoved': { story: Amity.InternalStory } & {
-        reactor: Amity.InternalReactor;
-      };
-
-      'local.story.error': Amity.StoryPayload;
-      'local.story.reload': { referenceIds: Amity.Story['referenceId'][] };
-
-      'local.notificationTraySeen.updated': Amity.InternalNotificationTraySeen;
-      'local.notificationTrayItem.updated': {
-        notificationTrayItems: Amity.InternalNotificationTrayItem[];
-      };
-
-      'local.invitation.created': Amity.InternalInvitation[];
-      'local.invitation.updated': Amity.InternalInvitation[];
-      'local.invitation.deleted': Amity.InternalInvitation[];
-
-      'v4.local.community.joined': Amity.InternalJoinRequest[];
-
-      'local.joinRequest.created': Amity.InternalJoinRequest[];
-      'local.joinRequest.updated': Amity.InternalJoinRequest[];
-      'local.joinRequest.deleted': Amity.InternalJoinRequest[];
-
-      'local.liveReaction.created': Amity.LiveReaction[];
-
-      sessionStateChange: Amity.SessionStates;
-      // used by accessTokenExpiryWatcher
-      tokenExpired: Amity.SessionStates.TOKEN_EXPIRED;
-      tokenTerminated: Amity.SessionStates.TERMINATED;
-      unreadCountEnabled: boolean;
-    } & LocalPostEvents &
-      LocalCommentEvents &
-      LocalCommunityEvents &
-      LocalFollowEvents;
-
-    type Events = WsEvents & MqttEvents & MqttRTE & LocalEvents;
-  }
-}

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

@@ -1,12 +0,0 @@
-export {};
-
-declare global {
-  namespace Amity {
-    type LinkPreview = {
-      title: string | null;
-      description: string | null;
-      image: string | null;
-      video: string | null;
-    };
-  }
-}

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

@@ -1,69 +0,0 @@
-export {};
-
-declare global {
-  namespace Amity {
-    type LiveObject<T extends any> = {
-      data: T;
-      error?: any;
-      loading: boolean;
-      origin?: 'local' | 'server' | 'event';
-    };
-
-    type LiveObjectCallback<T extends any> = Amity.Listener<LiveObject<T>>;
-
-    type LiveObjectOptions<T extends Amity.Models[Amity.Domain], CallbackData extends any = any> = {
-      forceDispatch?: boolean;
-      callbackDataSelector?: (data: T) => CallbackData;
-      callbackFilter?: (currentModel: T, previousModel: T) => boolean;
-    };
-
-    type LiveCollection<T extends any> = LiveObject<T[]> & {
-      onNextPage?: () => void;
-      hasNextPage?: boolean;
-      onPrevPage?: () => void;
-      hasPrevPage?: boolean;
-    };
-
-    type LiveCollectionCallback<T extends any> = Amity.Listener<LiveCollection<T>>;
-
-    type LiveCollectionConfig = {
-      policy?: Exclude<Amity.QueryPolicy, 'no_fetch'>;
-    };
-
-    type LiveCollectionParams<T extends any> = T & {
-      limit?: number;
-    };
-
-    type LiveCollectionCache<T extends any, U extends any> = Pick<
-      LiveCollection<T>,
-      'data' | 'error' | 'loading'
-    > & { params: U } & {
-      // some live collection cache did not have this property
-      query?: Omit<Amity.QueryMessages, 'page'>;
-    };
-
-    const enum LiveDataOrigin {
-      LOCAL = 'local',
-      SERVER = 'server',
-      EVENT = 'event',
-    }
-
-    type LiveCollectionNotifyParams = {
-      origin?: LiveDataOrigin;
-      loading: boolean;
-      error?: unknown;
-    };
-
-    const enum LiveCollectionPageDirection {
-      FIRST = 'first',
-      PREV = 'prev',
-      NEXT = 'next',
-    }
-
-    type LiveCollectionPersistQueryStreamParams<T extends keyof Amity.Payloads> = {
-      response: Amity.Payloads[T] & Partial<Amity.Pagination>;
-      direction: LiveCollectionPageDirection;
-      refresh?: boolean;
-    };
-  }
-}

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

@@ -1,57 +0,0 @@
-export {};
-
-declare global {
-  namespace Amity {
-    type ChannelMarker = {
-      entityId: Amity.RawChannel['channelId'];
-      userId: Amity.InternalUser['userId'];
-      unreadCount: number;
-      isDeleted: boolean;
-      hasMentioned: boolean;
-    } & Amity.Timestamps;
-
-    type SubChannelMarker = {
-      feedId: Amity.RawSubChannel['messageFeedId'];
-      entityId: Amity.RawChannel['channelId'];
-      userId: Amity.InternalUser['userId'];
-      readToSegment: number;
-      deliveredToSegment: number;
-      unreadCount: number;
-      hasMentioned: boolean;
-    } & Amity.Timestamps;
-
-    type MessageMarker = {
-      feedId: Amity.RawSubChannel['messageFeedId'];
-      contentId: Amity.RawMessage['messageId'];
-      creatorId: Amity.InternalUser['userId'];
-      readCount: number;
-      deliveredCount: number;
-    } & Amity.Timestamps;
-
-    type FeedMarker = {
-      feedId: Amity.RawSubChannel['messageFeedId'];
-      entityId: Amity.RawChannel['channelId'];
-      lastSegment: number;
-      isDeleted: boolean;
-    } & Amity.Timestamps;
-
-    type UserMarker = {
-      userId: Amity.InternalUser['userId'];
-      unreadCount: number;
-      isMentioned: boolean;
-    } & Amity.SyncAt &
-      Amity.Timestamps;
-
-    type UserFeedMarker = {
-      userId: Amity.InternalUser['userId'];
-      enityId: Amity.RawChannel['channelId'];
-      feedId: Amity.RawSubChannel['messageFeedId'];
-      readToSegment: number;
-      deliveredToSegment: number;
-      unreadCount: number;
-      oldUnreadCount: number;
-      lastMentionSegment: number;
-      isMentioned: boolean;
-    } & Amity.Timestamps;
-  }
-}

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

@@ -1,136 +0,0 @@
-export {};
-
-declare global {
-  namespace Amity {
-    /**
-     * type map of "domain name -> ASC model"
-     * @hidden
-     */
-    type Models = {
-      user: Amity.InternalUser;
-      file: Amity.File;
-      role: Amity.Role;
-
-      story: Amity.InternalStory;
-      storyTarget: Amity.RawStoryTarget;
-
-      channel: Amity.StaticInternalChannel;
-      subChannel: Amity.SubChannel;
-      channelUsers: Amity.Membership<'channel'>;
-      message: Amity.InternalMessage;
-
-      messagePreviewChannel: Amity.InternalMessagePreview;
-      messagePreviewSubChannel: Amity.InternalMessagePreview;
-
-      channelUnreadInfo: Amity.ChannelUnreadInfo;
-      subChannelUnreadInfo: Amity.SubChannelUnreadInfo;
-
-      channelUnread: Amity.ChannelUnread;
-
-      channelMarker: Amity.ChannelMarker;
-      subChannelMarker: Amity.SubChannelMarker;
-      messageMarker: Amity.MessageMarker;
-      feedMarker: Amity.FeedMarker;
-      userMarker: Amity.UserMarker;
-
-      community: Amity.InternalCommunity;
-      category: Amity.InternalCategory;
-      communityUsers: Amity.Membership<'community'>;
-      post: Amity.InternalPost;
-      comment: Amity.InternalComment;
-      commentChildren: Amity.InternalComment;
-      poll: Amity.Poll;
-      reaction: Amity.Reaction;
-      reactor: Amity.InternalReactor;
-
-      stream: Amity.InternalStream;
-      streamModeration: Amity.StreamModeration;
-
-      follow: Amity.FollowStatus;
-      followInfo: Amity.FollowInfo;
-      followCount: Amity.FollowCount;
-
-      feed: Amity.Feed;
-
-      ad: Amity.InternalAd;
-      advertiser: Amity.InternalAdvertiser;
-
-      pinTarget: Amity.InternalPinTarget;
-      pin: Amity.InternalPin;
-
-      notificationTrayItem: Amity.InternalNotificationTrayItem;
-      notificationTraySeen: Amity.InternalNotificationTraySeen;
-
-      invitation: Amity.InternalInvitation;
-
-      joinRequest: Amity.InternalJoinRequest;
-    };
-
-    type Model = ValueOf<Models>;
-    type Domain = keyof Models;
-
-    /**
-     * Definition of the minimal set of properties necessary to identify
-     * successfully a model.
-     * @hidden
-     */
-    type Minimal = {
-      user: Pick<Amity.InternalUser, 'userId'>;
-      file: Pick<Amity.File, 'fileId'>;
-      role: Pick<Amity.Role, 'roleId'>;
-
-      story: Pick<Amity.InternalStory, 'referenceId'>;
-      storyTarget: Pick<Amity.RawStoryTarget, 'targetId'>;
-
-      channel: Pick<Amity.Channel, 'channelInternalId'>;
-      subChannel: Pick<Amity.SubChannel, 'subChannelId'>;
-      channelUsers: Pick<Amity.Membership<'channel'>, 'channelId' | 'userId'>;
-      message: Pick<Amity.InternalMessage, 'messageId' | 'referenceId'>;
-
-      messagePreviewChannel: Pick<Amity.MessagePreview, 'channelId'>;
-      messagePreviewSubChannel: Pick<Amity.MessagePreview, 'subChannelId'>;
-
-      channelUnreadInfo: Pick<Amity.ChannelUnreadInfo, 'channelId'>;
-      subChannelUnreadInfo: Pick<Amity.SubChannelUnreadInfo, 'subChannelId'>;
-
-      channelUnread: Pick<Amity.ChannelUnread, 'channelId'>;
-
-      channelMarker: Pick<Amity.ChannelMarker, 'entityId' | 'userId'>;
-      subChannelMarker: Pick<Amity.SubChannelMarker, 'feedId' | 'entityId' | 'userId'>;
-      messageMarker: Pick<Amity.MessageMarker, 'feedId' | 'contentId' | 'creatorId'>;
-      feedMarker: Pick<Amity.FeedMarker, 'feedId' | 'entityId'>;
-      userMarker: Pick<Amity.UserMarker, 'userId'>;
-
-      community: Pick<Amity.Community, 'communityId'>;
-      category: Pick<Amity.InternalCategory, 'categoryId'>;
-      communityUsers: Pick<Amity.Membership<'community'>, 'communityId' | 'userId'>;
-      post: Pick<Amity.InternalPost, 'postId'>;
-      comment: Pick<Amity.InternalComment, 'commentId'>;
-      commentChildren: Pick<Amity.InternalComment, 'commentId'>;
-      poll: Pick<Amity.Poll, 'pollId'>;
-      reaction: Pick<Amity.Reaction, 'referenceType' | 'referenceId'>;
-      reactor: Pick<Amity.InternalReactor, 'reactionId'>;
-
-      stream: Pick<Amity.InternalStream, 'streamId'>;
-      streamModeration: Pick<Amity.StreamModeration, 'streamId'>;
-
-      follow: Pick<Amity.FollowStatus, 'from' | 'to'>;
-      followInfo: Pick<Amity.FollowInfo, 'userId' | 'status'>;
-      followCount: Pick<Amity.FollowInfo, 'userId' | 'followerCount'>;
-
-      feed: Pick<Amity.Feed, 'targetId' | 'feedId'>;
-
-      ad: Pick<Amity.InternalAd, 'adId'>;
-      advertiser: Pick<Amity.Advertiser, 'advertiserId'>;
-
-      pinTarget: Pick<Amity.InternalPinTarget, 'targetId'>;
-      pin: Pick<Amity.InternalPin, 'placement' | 'referenceId'>;
-
-      notificationTrayItem: Pick<Amity.InternalNotificationTrayItem, '_id'>;
-      notificationTraySeen: Pick<Amity.InternalNotificationTraySeen, 'userId'>;
-
-      invitation: Pick<Amity.InternalInvitation, '_id'>;
-      joinRequest: Pick<Amity.InternalJoinRequest, 'joinRequestId'>;
-    };
-  }
-}