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

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

@@ -0,0 +1,129 @@
+import { AxiosInstance } from 'axios';
+import { Emitter } from 'mitt';
+
+declare global {
+  namespace Amity {
+    type Logger = (topic: string, ...args: any[]) => void;
+
+    const enum TokenTerminationReason {
+      GLOBAL_BAN = 'globalBan',
+      USER_DELETED = 'userDeleted',
+      UNAUTHORIZED = 'unauthorized',
+    }
+
+    const enum SessionStates {
+      NOT_LOGGED_IN = 'notLoggedIn',
+
+      ESTABLISHING = 'establishing',
+      ESTABLISHED = 'established',
+
+      TOKEN_EXPIRED = 'tokenExpired',
+      /*
+       * Terminated is slightly different from NOT_LOGGED_IN:
+       *
+       * After established, upon receiving the termination code, the SDK will move to terminated.
+       * Unlike tokenExpired that users can regain SDK usability by giving an auth token.
+       * This state represents unrecoverable failures. The app must manually re-login with a valid user.
+       *
+       * For more details, please check tech spec:
+       * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#terminated
+       */
+      TERMINATED = 'terminated',
+    }
+
+    type Client = {
+      version: string;
+
+      log: Logger;
+      http: AxiosInstance;
+      mqtt: Amity.MqttClient;
+      ws: SocketIOClient.Socket;
+      emitter: Emitter<Amity.Events>;
+
+      sessionState: Amity.SessionStates;
+      sessionHandler?: Amity.SessionHandler;
+
+      cache?: Amity.Cache;
+
+      apiKey?: string;
+      userId?: string;
+
+      token?: Omit<Amity.Tokens, 'refreshToken'>;
+
+      use: () => void;
+
+      accessTokenExpiryWatcher: (
+        expiresAt: Amity.Tokens['expiresAt'],
+        issuedAt: Amity.Tokens['issuedAt'],
+        sessionHandler: Amity.SessionHandler,
+      ) => Amity.Unsubscriber;
+
+      getFeedSettings: () => Promise<Amity.FeedSettings>;
+    };
+
+    type Device = {
+      deviceId: string;
+      deviceInfo: {
+        kind: 'node' | 'web';
+        model?: string;
+        sdkVersion: string;
+      };
+    };
+
+    type Tokens = {
+      accessToken: string;
+      refreshToken: string;
+      // issuedAt, expiresAt is in iso Date format
+      issuedAt: string;
+      expiresAt: string;
+    };
+
+    type AccessTokenRenewal = {
+      renew: () => void;
+      renewWithAuthToken: (authToken: string) => void;
+      unableToRetrieveAuthToken: () => void;
+    };
+
+    interface SessionHandler {
+      sessionWillRenewAccessToken(renewal: AccessTokenRenewal): void;
+    }
+
+    type ChatSettings = {
+      enabled: boolean;
+      mention: {
+        isAllowMentionedChannelEnabled: boolean;
+      };
+    };
+
+    type FeedSettings = {
+      [name in Amity.ContentFeedType]?: Amity.ContentSetting[];
+    };
+
+    type SocialSettings = {
+      enabled: boolean;
+      isAllowEditPostWhenReviewingEnabled: boolean;
+      isFollowWithRequestEnabled: boolean;
+      globalFeed: {
+        showCommunityPost: boolean;
+        showEveryonePost: boolean;
+        showFollowingPost: boolean;
+        showMyPost: boolean;
+        showOnlyMyFeed: boolean;
+      };
+      userPrivacySetting: 'public' | 'private ';
+    };
+
+    type ConnectClientParams = {
+      userId: Amity.User['userId'];
+      displayName?: Amity.User['displayName'];
+      authToken?: string;
+      deviceId?: Amity.Device['deviceId'];
+    };
+
+    type ConnectClientConfig = {
+      disableRTE: boolean;
+    };
+
+    type ActiveUser = Pick<Amity.User, '_id' | 'userId' | 'path' | 'displayName'>;
+  }
+}

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

@@ -0,0 +1,65 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type CommentContentType = 'text';
+    type CommentReferenceType = 'content' | 'post';
+
+    type CommentActionType =
+      | 'onFetch'
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onReactionAdded'
+      | 'onReactionRemoved';
+
+    type Comment<T extends CommentContentType = any> = {
+      commentId: string;
+      userId: string;
+      parentId?: Comment['commentId'];
+      rootId: Comment['commentId'];
+      childrenNumber: number;
+      children: Comment['commentId'][];
+      segmentNumber: number;
+      editedAt: Amity.timestamp;
+      attachments?: Amity.Attachment[];
+    } & Amity.Relationship<CommentReferenceType> &
+      Amity.Content<T> &
+      Amity.Metadata &
+      Amity.Flaggable &
+      Amity.Reactable &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Mentionable<'user'>;
+
+    type QueryComments = {
+      referenceType: Amity.Comment['referenceType'];
+      referenceId: Amity.Comment['referenceId'];
+      sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
+      parentId?: Amity.Comment['commentId'] | null;
+      hasFlag?: boolean;
+      includeDeleted?: boolean;
+      page?: Amity.Page;
+      dataTypes?: {
+        values: ('image' | 'text')[];
+        // matchType is a query format that you can set to any to query any type of comment
+        // or exact to get a comment with exactly type that defined in dataTypes
+        matchType: 'any' | 'exact';
+      };
+    };
+
+    type CommentLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryComments, 'sortBy' | 'page'> & {
+        sortBy?: 'lastCreated' | 'firstCreated';
+      }
+    >;
+
+    type CommentLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Comment['commentId'],
+      Pick<QueryComments, 'page'>
+    >;
+  }
+}

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

@@ -0,0 +1,109 @@
+export const CommunityPostSettings = Object.freeze({
+  ONLY_ADMIN_CAN_POST: 'ONLY_ADMIN_CAN_POST',
+  ADMIN_REVIEW_POST_REQUIRED: 'ADMIN_REVIEW_POST_REQUIRED',
+  ANYONE_CAN_POST: 'ANYONE_CAN_POST',
+});
+
+export const CommunityPostSettingMaps = Object.freeze({
+  ONLY_ADMIN_CAN_POST: {
+    needApprovalOnPostCreation: false,
+    onlyAdminCanPost: true,
+  },
+  ADMIN_REVIEW_POST_REQUIRED: {
+    needApprovalOnPostCreation: true,
+    onlyAdminCanPost: false,
+  },
+  ANYONE_CAN_POST: {
+    needApprovalOnPostCreation: false,
+    onlyAdminCanPost: false,
+  },
+});
+
+export const DefaultCommunityPostSetting = 'ONLY_ADMIN_CAN_POST';
+
+declare global {
+  namespace Amity {
+    type CommunityActionType =
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onJoin'
+      | 'onLeft'
+      | 'onMemberCountChanged';
+
+    type CommunityMemberActionType =
+      | 'onJoin'
+      | 'onLeft'
+      | 'onBan'
+      | 'onUnban'
+      | 'onMemberCountChanged';
+
+    type RawCommunity = {
+      communityId: string;
+
+      displayName: string;
+      avatarFileId?: File<'image'>['fileId'];
+      description?: string;
+
+      channelId: Amity.Channel['channelId'];
+      userId: Amity.User['userId'];
+
+      isOfficial?: boolean;
+      isPublic?: boolean;
+      isJoined?: boolean;
+      onlyAdminCanPost?: boolean;
+      needApprovalOnPostCreation?: boolean;
+
+      postsCount: number;
+      membersCount: number;
+
+      categoryIds: Amity.Category['categoryId'][];
+
+      hasFlaggedComment: boolean;
+      hasFlaggedPost: boolean;
+    } & Amity.Taggable &
+      Amity.Metadata &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable;
+
+    type Community = Omit<Amity.RawCommunity, 'onlyAdminCanPost' | 'needApprovalOnPostCreation'> & {
+      postSetting?: ValueOf<typeof CommunityPostSettings>;
+    };
+
+    type QueryCommunities = {
+      displayName?: string;
+      membership?: 'all' | 'member' | 'notMember';
+      categoryId?: Amity.Category['categoryId'];
+      includeDeleted?: boolean;
+      tags?: Amity.Taggable['tags'];
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      page?: Amity.Page;
+    };
+
+    type CommunityLiveCollection = Amity.LiveCollectionParams<Omit<QueryCommunities, 'page'>>;
+
+    type CommunityLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Community['communityId'],
+      Pick<QueryCommunities, 'page'>
+    >;
+
+    type QueryCommunityMembers = {
+      communityId: string;
+      membership?: ('banned' | 'member')[];
+      roles?: string[];
+      sortBy?: 'firstCreated' | 'lastCreated';
+      search?: Amity.User['displayName'] | Amity.User['userId'];
+      page?: Amity.Page;
+    };
+
+    type CommunityMemberLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryCommunityMembers, 'page'>
+    >;
+
+    type CommunityMemberLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Membership<'community'>['userId'],
+      Pick<QueryCommunityMembers, 'page'>
+    >;
+  }
+}

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

@@ -0,0 +1,88 @@
+export const ContentFeedType = Object.freeze({
+  STORY: 'story',
+  CLIP: 'clip',
+  CHAT: 'chat',
+  POST: 'post',
+  MESSAGE: 'message',
+});
+
+declare global {
+  namespace Amity {
+    type ContentType = 'text' | 'image' | 'file' | 'video' | 'poll' | 'json' | string;
+
+    type ContentFeedType = ValueOf<typeof ContentFeedType>;
+
+    type ContentDataText = {
+      text: string;
+    };
+
+    type ContentDataFile = {
+      fileId: Amity.File<'file'>['fileId'];
+    };
+
+    type ContentDataImage = {
+      fileId: Amity.File<'image'>['fileId'];
+    };
+
+    type Attachment = {
+      type: 'image' | 'link';
+      url?: string;
+      fileId?: Amity.File<'image'>['fileId'];
+    };
+
+    type ContentDataVideo = {
+      thumbnailFileId: Amity.File<'image'>['fileId'];
+      videoFileId: {
+        [K in Amity.VideoSize]?: Amity.File<'video'>['fileId'];
+      };
+    };
+
+    type ContentDataPoll = {
+      pollId: Amity.Poll['pollId'];
+    };
+
+    type ContentData<T extends ContentType> = T extends 'text'
+      ? ContentDataText
+      : T extends 'file'
+      ? ContentDataFile
+      : T extends 'image'
+      ? ContentDataImage
+      : T extends 'video'
+      ? ContentDataVideo
+      : T extends 'poll'
+      ? ContentDataPoll
+      : T extends 'json'
+      ? Record<string, unknown>
+      : T extends string
+      ? string | Record<string, unknown> // custom type
+      : never;
+
+    type Content<T extends ContentType> = {
+      // dataType still retained to maintain backward compatibility
+      dataType?: T;
+      dataTypes?: T[];
+      data?: ContentData<T>;
+    };
+
+    type ContentSettingText = {
+      contentType: 'text';
+      allowed: boolean;
+    };
+
+    type ContentSettingVideo = {
+      contentType: 'video';
+      allowed: boolean;
+      maxDurationSeconds: number;
+      transcodeConfig: {
+        maxResolution: Amity.VideoResolution;
+        minResolution: Amity.VideoResolution;
+      };
+    };
+
+    type ContentSetting<T extends ContentType = 'text' | 'video'> = T extends 'text'
+      ? ContentSettingText
+      : T extends 'video'
+      ? ContentSettingVideo
+      : never;
+  }
+}

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

@@ -0,0 +1,13 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type Feed = {
+      feedId: string;
+      feedType: 'reviewing' | 'published';
+      targetType: Extract<Amity.Domain, 'community' | 'user'>;
+      targetId: string;
+      postCount: number;
+    } & Amity.Timestamps;
+  }
+}

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

@@ -0,0 +1,80 @@
+export const FileType = Object.freeze({
+  FILE: 'file',
+  IMAGE: 'image',
+  VIDEO: 'video',
+});
+
+export const VideoResolution = Object.freeze({
+  '1080P': '1080p',
+  '720P': '720p',
+  '480P': '480p',
+  '360P': '360p',
+  ORIGINAL: 'original',
+});
+
+export const VideoTranscodingStatus = Object.freeze({
+  UPLOADED: 'uploaded',
+  TRANSCODING: 'transcoding',
+  TRANSCODED: 'transcoded',
+  TRANSCODE_FAILED: 'transcodeFailed',
+});
+
+export const VideoSize = Object.freeze({
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high',
+  ORIGINAL: 'original',
+});
+
+declare global {
+  namespace Amity {
+    type FileType = ValueOf<typeof FileType>;
+
+    type VideoResolution = ValueOf<typeof VideoResolution>;
+
+    type VideoTranscodingStatus = ValueOf<typeof VideoTranscodingStatus>;
+
+    type VideoSize = ValueOf<typeof VideoSize>;
+
+    type FileMetadata = Record<string, never>;
+
+    type ImageMetadata = {
+      exif: Record<string, unknown>;
+      gps: Record<string, unknown>;
+      width: number;
+      height: number;
+      isFull: boolean;
+    };
+
+    type VideoMetadata = Record<string, never>;
+
+    type MetadataFor<T extends FileType> = T extends 'file'
+      ? FileMetadata
+      : T extends 'image'
+      ? ImageMetadata
+      : T extends 'video'
+      ? VideoMetadata
+      : never;
+
+    type VideoFileExtraPayload = {
+      feedType: Amity.ContentFeedType;
+      status: VideoTranscodingStatus;
+      videoUrl?: { [name in VideoResolution]?: string } | null;
+    };
+
+    type File<T extends FileType = any> = {
+      fileId: string;
+      type: T;
+      fileUrl: string;
+      attributes: {
+        name: string;
+        extension: string;
+        size: string;
+        mimeType: string;
+        metadata: MetadataFor<T>;
+      };
+    } & (T extends 'video' ? VideoFileExtraPayload : unknown) &
+      Amity.Timestamps &
+      Amity.SoftDelete;
+  }
+}

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

@@ -0,0 +1,53 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type FollowActionType =
+      | 'onRequested'
+      | 'onAccepted'
+      | 'onDeclined'
+      | 'onCanceled'
+      | 'onFollowed'
+      | 'onUnfollowed'
+      | 'onDeleted';
+
+    type FollowStatusType = 'all' | 'pending' | 'accepted' | 'blocked' | 'none';
+
+    type FollowStatus = {
+      from: Amity.User['userId'];
+      to: Amity.User['userId'];
+      status: Exclude<FollowStatusType, 'all'>;
+    } & Amity.CreatedAt &
+      Amity.UpdatedAt;
+
+    type FollowCount = {
+      userId: Amity.User['userId'];
+      followerCount: number;
+      followingCount: number;
+      pendingCount: number;
+    };
+
+    type FollowInfo = {
+      status?: FollowStatus['status'];
+    } & FollowCount;
+
+    type QueryFollowers = {
+      userId: Amity.User['userId'];
+      status?: Exclude<Amity.FollowStatusType, 'none'>;
+      page?: Amity.PageRaw;
+    };
+
+    type FollowerLiveCollection = Amity.LiveCollectionParams<Omit<QueryFollowers, 'page'>>;
+
+    type FollowerLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.FollowInfo['userId'],
+      Pick<QueryFollowers, 'page'>
+    >;
+
+    type QueryFollowings = QueryFollowers;
+
+    type FollowingLiveCollection = FollowerLiveCollection;
+
+    type FollowingLiveCollectionCache = FollowerLiveCollectionCache;
+  }
+}

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

@@ -0,0 +1,40 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type GroupType = 'channel' | 'community';
+
+    type Group = {
+      membersCount: number;
+    };
+
+    type Member<T extends GroupType> = {
+      userId: Amity.User['userId'];
+    } & (T extends 'channel'
+      ? {
+          channelId: Amity.Channel['channelId'];
+          membership: 'member' | 'none' | 'banned';
+          readToSegment: number;
+          lastMentionedSegment: number;
+        }
+      : T extends 'community'
+      ? {
+          communityId: Amity.Community['communityId'];
+          communityMembership: 'member' | 'none' | 'banned';
+        }
+      : never) &
+      Amity.Timestamps;
+
+    type MemberWithUser<T extends GroupType> = Member<T> & { user: Amity.User | undefined };
+
+    type RawMembership<T extends GroupType, WithUser = false> = {
+      isBanned: boolean;
+      isMuted: boolean;
+      muteTimeout: string;
+      lastActivity: Amity.timestamp;
+    } & (WithUser extends true ? MemberWithUser<T> : Member<T>) &
+      Amity.Accredited;
+
+    type Membership<T extends Amity.GroupType> = Amity.RawMembership<T, true>;
+  }
+}

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

@@ -0,0 +1,20 @@
+export {};
+
+declare global {
+  namespace Amity {
+    const enum MarkerSyncEvent {
+      START_SYNCING = 'start syncing',
+      HAS_MORE = 'has_more',
+      NEW_MESSAGE = 'new message',
+      RESUME = 'resume',
+      CHANNEL_CREATED = 'subchannel is created',
+      CHANNEL_DELETED = 'subchannel is deleted',
+      CHANNEL_JOINED = 'subchannel is joined',
+      CHANNEL_LEFT = 'subchannel is left',
+      SUB_CHANNEL_CREATED = 'subchannel is created',
+      SUBCHANNEL_IS_DELETED = 'subchannel is deleted',
+      FORCE_SYNC = 'force sync',
+      MARKER_UPDATED = 'feed marker updated',
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type Mention = {
+      type: 'user' | 'channel';
+    };
+
+    type ChannelMention = Mention & {
+      type: 'channel';
+    };
+
+    type UserMention = Mention & {
+      type: 'user';
+      userIds: string[];
+    };
+
+    type MentionType = {
+      channel: ChannelMention;
+      user: UserMention;
+    };
+
+    type Mentionable<T extends keyof MentionType = 'channel' | 'user'> = {
+      mentionees?: MentionType[T][];
+    };
+  }
+}