@amityco/ts-sdk-react-native 6.29.3-669217e.0 → 6.30.0

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

@@ -139,13 +139,13 @@ declare global {
     };
 
     type MqttFollowEvents = {
-      'follow.created': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.requested': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.accepted': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.unfollowed': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.requestCanceled': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.requestDeclined': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.followerDeleted': Amity.FollowersPayload | Amity.FollowStatusPayload;
+      '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 = {
@@ -166,6 +166,35 @@ declare global {
       MqttMarkerEvents &
       MqttStoryEvents;
 
+    type LocalPostEvents = {
+      'local.post.updated': Amity.PostPayload;
+      'local.post.deleted': Amity.PostPayload;
+      'local.post.addReaction': { post: Amity.InternalPost };
+      'local.post.removeReaction': { post: Amity.InternalPost };
+    };
+
+    type LocalCommentEvents = {
+      'local.comment.created': Amity.CommentPayload;
+      'local.comment.deleted': Amity.CommentPayload;
+      'local.comment.addReaction': { comment: Amity.InternalComment };
+      'local.comment.removeReaction': { comment: Amity.InternalComment };
+    };
+
+    type LocalCommunityEvents = {
+      '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.InternalChannel[];
@@ -213,17 +242,15 @@ declare global {
       'local.story.error': Amity.StoryPayload;
       'local.story.reload': { referenceIds: Amity.Story['referenceId'][] };
 
-      'local.post.updated': Amity.PostPayload;
-
-      'local.comment.created': Amity.CommentPayload;
-      'local.comment.deleted': Amity.CommentPayload;
-
       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/model.ts

@@ -52,6 +52,9 @@ declare global {
 
       ad: Amity.InternalAd;
       advertiser: Amity.InternalAdvertiser;
+
+      pinTarget: Amity.InternalPinTarget;
+      pin: Amity.InternalPin;
     };
 
     type Model = ValueOf<Models>;
@@ -108,6 +111,9 @@ declare global {
 
       ad: Pick<Amity.InternalAd, 'adId'>;
       advertiser: Pick<Amity.Advertiser, 'advertiserId'>;
+
+      pinTarget: Pick<Amity.InternalPinTarget, 'targetId'>;
+      pin: Pick<Amity.InternalPin, 'placement' | 'referenceId'>;
     };
   }
 }

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

@@ -20,9 +20,18 @@ declare global {
       story: Amity.StoryPayload;
       globalStoryFeed: Amity.GlobalStoryFeedPayload;
       reaction: Amity.ReactionPayload;
+      pinnedPost: Amity.PinnedPostPayload;
+      follower: Amity.FollowersPayload;
+      following: Amity.FollowingsPayload;
+      blockUser: Amity.BlockedUserPayload;
     };
 
     type UserPayload = {
+      users: Amity.RawUser[];
+      files: Amity.File<'image'>[];
+    };
+
+    type ProcessedUserPayload = {
       users: Amity.InternalUser[];
       files: Amity.File<'image'>[];
     };
@@ -49,12 +58,12 @@ declare global {
       roles: Amity.Role[];
     };
 
-    type ChannelPayload<T extends Amity.ChannelType = any> = {
+    type ChannelPayload<T extends Amity.ChannelType = any> = Amity.UserPayload & {
       channels: Amity.RawChannel<T>[];
       channelUsers: Amity.RawMembership<'channel'>[];
       messagePreviews: Amity.MessagePreviewPayload[];
       messageFeedsInfo?: Amity.messageFeedsInfoPayload[];
-    } & Amity.UserPayload;
+    };
 
     /**
      * Items that extend from `Amity.Channel`
@@ -63,10 +72,11 @@ declare global {
      */
     type ProcessedChannelPayload<T extends Amity.ChannelType = any> = Omit<
       ChannelPayload,
-      'channels' | 'channelUsers' | 'messagePreviews' | 'messageFeedsInfo'
+      'channels' | 'channelUsers' | 'messagePreviews' | 'messageFeedsInfo' | 'users'
     > & {
       channels: Amity.InternalChannel<T>[];
       channelUsers: Amity.Membership<'channel'>[];
+      users: Amity.InternalUser[];
     };
 
     type UserMarkerResponse = Omit<Amity.UserMarker, 'hasMentioned'> & Amity.IsMentioned;
@@ -210,7 +220,8 @@ declare global {
       channels: Amity.RawChannel[];
       channelUsers: Amity.RawMembership<'channel'>[];
       messagePreviews: Amity.MessagePreviewPayload[];
-    } & Amity.UserPayload;
+      users: Amity.RawUser[];
+    } & Omit<Amity.UserPayload, 'users'>;
 
     /**
      * Items that extend from `Amity.ChannelMembershipPayload`
@@ -379,14 +390,26 @@ declare global {
     type GlobalFeedPayload = Amity.PostPayload;
 
     type FollowStatusPayload = {
-      follows: Amity.FollowStatus[];
+      follows: Amity.RawFollowStatus[];
+    };
+
+    type ProcessedFollowStatusPayload = {
+      follows: Amity.InternalFollowStatus[];
     };
 
     type FollowInfoMePayload = {
       followCounts: Amity.FollowCount[];
     };
 
-    type FollowersPayload = Amity.FollowStatusPayload & UserPayload;
+    type FollowersPayload = Amity.FollowStatusPayload & Amity.UserPayload;
+
+    type ProcessedFollowersPayload = Amity.ProcessedFollowStatusPayload & {
+      users: Amity.InternalUser[];
+    };
+
+    type FollowingsPayload = Amity.FollowersPayload;
+
+    type ProcessedFollowingsPayload = Amity.ProcessedFollowersPayload;
 
     type FollowInfoPayload = FollowInfoMePayload & Amity.FollowStatusPayload;
 
@@ -395,9 +418,16 @@ declare global {
       followCounts: Amity.FollowCount[];
     };
 
-    type BlockedUserPayload = Amity.FollowStatusPayload[] &
-      Amity.UserPayload &
-      Amity.BlockedUserPaged;
+    type ProcessedBlockedPayload = {
+      follows: Amity.ProcessedFollowStatusPayload['follows'];
+      followCounts: Amity.FollowCount[];
+    };
+
+    type BlockedUserPayload = Amity.FollowersPayload;
+
+    type ProcessedBlockedUserPayload = Amity.BlockedUserPayload & {
+      users: Amity.InternalUser[];
+    };
 
     type MessagePreviewPayload<T extends Amity.MessageContentType = any> = {
       messageId: string;

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

@@ -31,10 +31,10 @@ declare global {
       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',
+      EditCommunityFeedPostPermission = 'EDIT_COMMUNITY_POST',
+      DeleteCommunityFeedPostPermission = 'DELETE_COMMUNITY_POST',
+      EditCommunityFeedCommentPermission = 'EDIT_COMMUNITY_COMMENT',
+      DeleteCommunityFeedCommentPermission = 'DELETE_COMMUNITY_COMMENT',
       CreateCommunityCategoryPermission = 'CREATE_COMMUNITY_CATEGORY',
       EditCommunityCategoryPermission = 'EDIT_COMMUNITY_CATEGORY',
       DeleteCommunityCategoryPermission = 'DELETE_COMMUNITY_CATEGORY',

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

@@ -129,6 +129,7 @@ declare global {
       sortBy?: 'firstCreated' | 'lastCreated';
       search?: string;
       page?: Amity.Page;
+      includeDeleted?: boolean;
     };
 
     type SearchChannelMembers = Amity.LiveCollectionParams<Omit<QueryChannelMembers, 'sortBy'>>;
@@ -145,6 +146,18 @@ declare global {
       >
     >;
 
+    type SearchChannelMembersLiveCollection = Amity.LiveCollectionParams<
+      Omit<
+        SearchChannelMembers,
+        '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'>

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

@@ -15,13 +15,13 @@ declare global {
       | 'onReactionAdded'
       | 'onReactionRemoved';
 
-    type InternalComment<T extends CommentContentType = any> = {
+    type RawComment<T extends CommentContentType = any> = {
       commentId: string;
       userId: string;
-      parentId?: InternalComment['commentId'];
-      rootId: InternalComment['commentId'];
+      parentId?: RawComment['commentId'];
+      rootId: RawComment['commentId'];
       childrenNumber: number;
-      children: InternalComment['commentId'][];
+      children: RawComment['commentId'][];
       segmentNumber: number;
       editedAt: Amity.timestamp;
       attachments?: Amity.Attachment[];
@@ -37,6 +37,8 @@ declare global {
       Amity.Subscribable &
       Amity.Mentionable<'user'>;
 
+    type InternalComment<T extends CommentContentType = any> = RawComment<T>;
+
     type CommentTarget = {
       type: InternalComment['targetType'] | 'unknown';
       communityId?: Amity.Community['communityId'];

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

@@ -23,6 +23,40 @@ export const DefaultCommunityPostSetting = 'ONLY_ADMIN_CAN_POST';
 
 declare global {
   namespace Amity {
+    const enum CommunitySortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      /** @deprecated sortBy displayName is not available */
+      DisplayName = 'displayName',
+    }
+
+    type CommunitySortBy = `${Amity.CommunitySortByEnum}`;
+
+    const enum SearchCommunitySortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      DisplayName = 'displayName',
+    }
+
+    type SearchCommunitySortBy = `${Amity.SearchCommunitySortByEnum}`;
+
+    const enum CommunityMemberSortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      /** @deprecated sortBy displayName is not available */
+      DisplayName = 'displayName',
+    }
+
+    type CommunityMemberSortBy = `${Amity.CommunityMemberSortByEnum}`;
+
+    const enum SearchCommunityMemberSortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      DisplayName = 'displayName',
+    }
+
+    type SearchCommunityMemberSortBy = `${Amity.SearchCommunityMemberSortByEnum}`;
+
     type CommunityActionType =
       | 'onCreate'
       | 'onUpdate'
@@ -81,11 +115,7 @@ declare global {
       categoryId?: Amity.InternalCategory['categoryId'];
       includeDeleted?: boolean;
       tags?: Amity.Taggable['tags'];
-      sortBy?:
-        | 'firstCreated'
-        | 'lastCreated'
-        /** @deprecated sortBy displayName is not available */
-        | 'displayName';
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
       page?: string;
       limit?: number;
     };
@@ -96,7 +126,7 @@ declare global {
       categoryId?: Amity.InternalCategory['categoryId'];
       includeDeleted?: boolean;
       tags?: Amity.Taggable['tags'];
-      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      sortBy?: Amity.SearchCommunitySortBy | Amity.SearchCommunitySortByEnum;
       page?: string;
       limit?: number;
     };
@@ -121,25 +151,23 @@ declare global {
       communityId: string;
       memberships?: ('banned' | 'member')[];
       roles?: string[];
-      sortBy?:
-        | 'firstCreated'
-        | 'lastCreated'
-        /** @deprecated sortBy displayName is not available */
-        | 'displayName';
+      sortBy?: Amity.CommunityMemberSortByEnum | Amity.CommunityMemberSortBy;
       /** @deprecated use searchCommunityMembers instead */
       search?: Amity.InternalUser['displayName'] | Amity.InternalUser['userId'];
       page?: string;
       limit?: number;
+      includeDeleted?: boolean;
     };
 
     type QuerySearchCommunityMembers = {
       communityId: string;
       memberships?: ('banned' | 'member')[];
       roles?: string[];
-      sortBy?: 'firstCreated' | 'lastCreated' | 'displayName';
+      sortBy?: Amity.SearchCommunityMemberSortByEnum | Amity.SearchCommunityMemberSortBy;
       search?: Amity.InternalUser['displayName'] | Amity.InternalUser['userId'];
       page?: string;
       limit?: number;
+      includeDeleted?: boolean;
     };
 
     type CommunityMemberLiveCollection = Amity.LiveCollectionParams<

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

@@ -2,24 +2,38 @@ export {};
 
 declare global {
   namespace Amity {
-    type FollowActionType =
-      | 'onRequested'
-      | 'onAccepted'
-      | 'onDeclined'
-      | 'onCanceled'
-      | 'onFollowed'
-      | 'onUnfollowed'
-      | 'onDeleted';
-
-    type FollowStatusType = 'all' | 'pending' | 'accepted' | 'blocked' | 'none';
-
-    type FollowStatus = {
+    const enum FollowActionTypeEnum {
+      OnRequested = 'onRequested',
+      OnAccepted = 'onAccepted',
+      OnDeclined = 'onDeclined',
+      OnCanceled = 'onCanceled',
+      OnFollowed = 'onFollowed',
+      OnUnfollowed = 'onUnfollowed',
+      OnDeleted = 'onDeleted',
+    }
+
+    type FollowActionType = `${FollowActionTypeEnum}`;
+
+    const enum FollowStatusTypeEnum {
+      All = 'all',
+      Pending = 'pending',
+      Accepted = 'accepted',
+      Blocked = 'blocked',
+      None = 'none',
+    }
+
+    type FollowStatusType = `${FollowStatusTypeEnum}`;
+
+    type RawFollowStatus = {
       from: Amity.InternalUser['userId'];
       to: Amity.InternalUser['userId'];
       status: Exclude<FollowStatusType, 'all'>;
     } & Amity.CreatedAt &
       Amity.UpdatedAt;
 
+    type InternalFollowStatus = Amity.RawFollowStatus;
+    type FollowStatus = InternalFollowStatus;
+
     type FollowCount = {
       userId: Amity.InternalUser['userId'];
       followerCount: number;

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

@@ -2,14 +2,18 @@ export {};
 
 declare global {
   namespace Amity {
-    type GroupType = 'channel' | 'community';
+    enum GroupTypeEnum {
+      CHANNEL = 'channel',
+      COMMUNITY = 'community',
+    }
+    type GroupType = `${GroupTypeEnum}`;
     type GroupMembership = 'member' | 'none' | 'banned' | 'muted';
 
     type Group = {
       membersCount: number;
     };
 
-    type Member<T extends GroupType> = {
+    type Member<T extends Amity.GroupType> = {
       userId: Amity.InternalUser['userId'];
     } & (T extends 'channel'
       ? {
@@ -26,16 +30,20 @@ declare global {
       : never) &
       Amity.Timestamps;
 
-    type MemberWithUser<T extends GroupType> = Member<T> & { user: Amity.InternalUser | undefined };
+    type MemberWithUser<T extends Amity.GroupType> = Member<T> & {
+      readonly user?: Amity.InternalUser;
+    };
 
-    type RawMembership<T extends GroupType, WithUser = false> = {
+    type RawMembership<T extends Amity.GroupType> = {
       isBanned: boolean;
       isMuted: boolean;
       muteTimeout: string;
       lastActivity: Amity.timestamp;
-    } & (WithUser extends true ? MemberWithUser<T> : Member<T>) &
+    } & Amity.Member<T> &
       Amity.Accredited;
 
-    type Membership<T extends Amity.GroupType> = Amity.RawMembership<T, true>;
+    type Membership<T extends Amity.GroupType> = Amity.RawMembership<T> & {
+      readonly user?: Amity.InternalUser;
+    };
   }
 }

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

@@ -0,0 +1,27 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type RawPin = {
+      referenceId: string; // postId
+      referenceType: string; // post
+      placement: string; // 'default' | 'announcement'
+      pinnedBy: string; // userId
+      pinnedAt: Date;
+    };
+
+    type RawPinTarget = {
+      targetId: string; // communityId | messageFeedId
+      targetType: string; // community | messageFeed
+      lastPinsUpdatedAt: Date;
+    };
+
+    type InternalPin = RawPin;
+
+    type InternalPinTarget = RawPinTarget;
+
+    type Pin = InternalPin;
+
+    type PinTarget = InternalPinTarget;
+  }
+}

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

@@ -0,0 +1,35 @@
+export {};
+
+declare global {
+  namespace Amity {
+    // Raw response from BE, not contain all linked objects
+    type PinnedPostPayload<T extends Amity.PostContentType = any> = {
+      pinTargets: Amity.RawPinTarget[];
+      pins: Amity.RawPin[];
+      posts: Amity.RawPost<T>[];
+      postChildren: Amity.RawPost<T>[];
+      comments: Amity.RawComment[];
+      videoStreamings: Amity.RawStream[];
+      polls: Amity.RawPoll[];
+    } & Amity.CommunityPayload;
+
+    type PinnedPostLiveCollection = Amity.LiveCollectionParams<{
+      communityId: Amity.Community['communityId'];
+      placement?: string | null;
+      sortBy: 'lastPinned' | 'lastCreated';
+    }>;
+
+    type PinnedPostLiveCollectionCache = Omit<
+      Amity.LiveCollectionCache<Amity.InternalPin['referenceId'], Amity.Page>,
+      'params'
+    >;
+
+    type PinnedPost = {
+      post: Amity.Post | undefined;
+      placement: Amity.Pin['placement'];
+      target: Amity.PinTarget | undefined;
+      pinnedBy: Amity.User;
+      pinnedAt: Date;
+    };
+  }
+}

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

@@ -16,7 +16,7 @@ declare global {
 
     type PollStatus = 'closed' | 'open';
 
-    type Poll = {
+    type RawPoll = {
       pollId: string;
       question: string;
       answers: PollAnswer[];
@@ -28,5 +28,9 @@ declare global {
       userId: Amity.InternalUser['userId'];
     } & Amity.Timestamps &
       Amity.SoftDelete;
+
+    type InternalPoll = RawPoll;
+
+    type Poll = InternalPoll;
   }
 }

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

@@ -26,15 +26,15 @@ declare global {
       | 'onReactionAdded'
       | 'onReactionRemoved';
 
-    type InternalPost<T extends PostContentType = any> = {
+    type RawPost<T extends PostContentType = any> = {
       postId: string;
-      postedUserId: Amity.InternalUser['userId']; // API-FIX: it should be "userId"
-      parentId: Amity.InternalPost['postId'];
-      parentPostId: Amity.InternalPost['postId'];
+      postedUserId: Amity.RawUser['userId'];
+      parentId: Amity.RawPost['postId'];
+      parentPostId: Amity.RawPost['postId'];
       targetType: PostTargetType;
       targetId: string;
       feedId: Amity.Feed['feedId'];
-      children: Amity.InternalPost['postId'][];
+      children: Amity.RawPost['postId'][];
       comments: Amity.InternalComment['commentId'][];
       commentsCount: number; // API-FIX: backend doesn't follow its own convention
       hasFlaggedChildren: false;
@@ -51,6 +51,10 @@ declare global {
       Amity.AnalyticPostData &
       Amity.Mentionable<'user'>;
 
+    type InternalPost<T extends PostContentType = any> = RawPost<T> & {
+      feedType?: 'reviewing' | 'published';
+    };
+
     type PostLinkObject = {
       latestComments: (Amity.Comment | null)[];
       creator: Amity.User | undefined;

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

@@ -44,7 +44,7 @@ declare global {
       stopTime: number;
     };
 
-    type InternalStream = {
+    type RawStream = {
       streamId: string;
       title: string;
       thumbnailFileId?: Amity.File<'image'>['fileId'];
@@ -65,6 +65,8 @@ declare global {
       Amity.Timestamps &
       Amity.SoftDelete;
 
+    type InternalStream = RawStream;
+
     type StreamLinkedObject = {
       moderation?: Amity.StreamModeration;
     };