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

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

@@ -1,180 +0,0 @@
-import { AxiosInstance } from 'axios';
-import { Emitter } from 'mitt';
-
-export const enum MembershipAcceptanceTypeEnum {
-  AUTOMATIC = 'automatic',
-  INVITATION = 'invitation',
-}
-
-declare global {
-  namespace Amity {
-    type Logger = (topic: string, ...args: any[]) => void;
-
-    type MembershipAcceptanceType = MembershipAcceptanceTypeEnum;
-
-    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;
-      upload: AxiosInstance;
-      mqtt?: Amity.MqttClient;
-      emitter: Emitter<Amity.Events>;
-
-      hasPermission: (permission: string) => Amity.PermissionChecker;
-      validateUrls: (urls: string[]) => Promise<boolean>;
-      validateTexts: (texts: string[]) => Promise<boolean>;
-
-      sessionState: Amity.SessionStates;
-      sessionHandler?: Amity.SessionHandler;
-
-      cache?: Amity.Cache;
-
-      apiKey?: string;
-      userId?: string;
-
-      token?: Amity.Tokens;
-
-      isUnreadCountEnabled: boolean;
-
-      useLegacyUnreadCount: boolean;
-
-      use: () => void;
-
-      accessTokenExpiryWatcher: (sessionHandler: Amity.SessionHandler) => Amity.Unsubscriber;
-
-      getFeedSettings: () => Promise<Amity.FeedSettings>;
-      getSocialSettings: () => Promise<Amity.SocialSettings>;
-      getMessagePreviewSetting: (refresh?: boolean) => Promise<Amity.MessagePreviewSetting>;
-
-      getMarkerSyncConsistentMode: () => boolean;
-
-      prefixDeviceIdKey?: string;
-
-      getVisitorDeviceId: () => Promise<string>;
-    };
-
-    type Device = {
-      deviceId: string;
-      deviceInfo: {
-        kind: 'node' | 'web';
-        model?: string;
-        sdkVersion: string;
-      };
-    };
-
-    type Tokens = {
-      accessToken: string;
-      // issuedAt, expiresAt is in iso Date format
-      issuedAt: string;
-      expiresAt: string;
-    };
-
-    type SessionResponse = Tokens & {
-      users: Amity.RawUser[];
-      userType: Amity.UserType;
-    };
-
-    type AccessTokenRenewal = {
-      renew: () => void;
-      renewWithAuthToken: (authToken: string) => void;
-      unableToRetrieveAuthToken: () => void;
-      renewWithAuthSignature: ({
-        authSignature,
-        authSignatureExpiresAt,
-      }: Amity.ConnectClientAsVisitorParams) => void;
-      unableToRetrieveAuthSignature: () => void;
-    };
-
-    interface SessionHandler {
-      sessionWillRenewAccessToken(renewal: AccessTokenRenewal): void;
-    }
-
-    type ChatSettings = {
-      enabled: boolean;
-      mention: {
-        isAllowMentionedChannelEnabled: boolean;
-      };
-      messagePreview: {
-        enabled: boolean;
-        isIncludeDeleted: boolean;
-      };
-    };
-
-    type ShareableLinkConfiguration = {
-      domain: string;
-      patterns: Record<string, string>;
-    };
-
-    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;
-      };
-      story: {
-        allowAllUserToCreateStory: boolean;
-        expiryTimeMinutes: number;
-      };
-      userPrivacySetting: 'public' | 'private';
-      membershipAcceptance: Amity.MembershipAcceptanceType;
-    };
-
-    type ConnectClientParams = {
-      userId: Amity.InternalUser['userId'];
-      displayName?: Amity.InternalUser['displayName'];
-      authToken?: string;
-      deviceId?: Amity.Device['deviceId'];
-    };
-
-    type ConnectClientAsVisitorParams = {
-      authSignature?: string;
-      authSignatureExpiresAt?: string;
-    };
-
-    type ConnectClientConfig = {
-      disableRTE: boolean;
-    };
-
-    type ActiveUser = Pick<Amity.InternalUser, '_id' | 'userId' | 'path' | 'displayName'>;
-
-    type UserUnread = Pick<Amity.UserMarker, 'unreadCount'> & {
-      isMentioned: boolean;
-    };
-  }
-}

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

@@ -1,83 +0,0 @@
-export {};
-
-declare global {
-  namespace Amity {
-    type CommentContentType = 'text';
-    type CommentReferenceType = 'content' | 'post' | 'story';
-
-    type CommentActionType =
-      | 'onFetch'
-      | 'onCreate'
-      | 'onUpdate'
-      | 'onDelete'
-      | 'onFlagged'
-      | 'onUnflagged'
-      | 'onReactionAdded'
-      | 'onReactionRemoved';
-
-    type RawComment<T extends CommentContentType = any> = {
-      commentId: string;
-      userId: string;
-      parentId?: RawComment['commentId'];
-      rootId: RawComment['commentId'];
-      childrenNumber: number;
-      children: RawComment['commentId'][];
-      segmentNumber: number;
-      editedAt: Amity.timestamp;
-      attachments?: Amity.Attachment[];
-      targetId: string;
-      targetType: 'community' | 'user' | 'content';
-    } & Amity.Relationship<CommentReferenceType> &
-      Amity.Content<T> &
-      Amity.Metadata &
-      Amity.Flaggable &
-      Amity.Reactable &
-      Amity.Timestamps &
-      Amity.SoftDelete &
-      Amity.Subscribable &
-      Amity.Mentionable<'user'>;
-
-    type InternalComment<T extends CommentContentType = any> = RawComment<T>;
-
-    type CommentTarget = {
-      type: InternalComment['targetType'] | 'unknown';
-      communityId?: Amity.Community['communityId'];
-      userId?: Amity.InternalUser['userId'];
-      contentId?: string;
-      creatorMember?: Amity.Membership<'community'>;
-    };
-
-    type Comment<T extends CommentContentType = any> = Amity.InternalComment<T> & {
-      target: Amity.CommentTarget;
-      creator?: Amity.User;
-    };
-
-    type QueryComments = {
-      referenceType: Amity.InternalComment['referenceType'];
-      referenceId: Amity.InternalComment['referenceId'];
-      sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
-      parentId?: Amity.InternalComment['commentId'] | null;
-      hasFlag?: boolean;
-      includeDeleted?: boolean;
-      limit?: number;
-      page?: Amity.Token;
-      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.InternalComment['commentId'],
-      { page?: Amity.Token | undefined; limit?: number }
-    >;
-  }
-}

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

@@ -1,294 +0,0 @@
-import { AmityCommunityMemberStatusFilter } from '~/communityRepository/constants';
-
-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 {
-    const enum CommunitySortByEnum {
-      FirstCreated = 'firstCreated',
-      LastCreated = 'lastCreated',
-      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',
-    }
-
-    type CommunityMemberSortBy = `${Amity.CommunityMemberSortByEnum}`;
-
-    const enum SearchCommunityMemberSortByEnum {
-      FirstCreated = 'firstCreated',
-      LastCreated = 'lastCreated',
-      DisplayName = 'displayName',
-    }
-
-    type SearchCommunityMemberSortBy = `${Amity.SearchCommunityMemberSortByEnum}`;
-
-    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.InternalUser['userId'];
-
-      isOfficial?: boolean;
-      isPublic?: boolean;
-      isJoined?: boolean;
-      onlyAdminCanPost?: boolean;
-      needApprovalOnPostCreation?: boolean;
-
-      postsCount: number;
-      membersCount: number;
-
-      categoryIds: Amity.InternalCategory['categoryId'][];
-
-      hasFlaggedComment: boolean;
-      hasFlaggedPost: boolean;
-
-      allowCommentInStory?: boolean;
-
-      isDiscoverable?: boolean;
-      requiresJoinApproval?: boolean;
-    } & Amity.Taggable &
-      Amity.Metadata &
-      Amity.Timestamps &
-      Amity.SoftDelete &
-      Amity.Subscribable;
-
-    type InternalCommunity = Omit<
-      Amity.RawCommunity,
-      'onlyAdminCanPost' | 'needApprovalOnPostCreation'
-    > &
-      Amity.CommunityStorySettings & {
-        postSetting?: ValueOf<typeof CommunityPostSettings>;
-      };
-
-    type Community = Amity.InternalCommunity & Amity.CommunityLinkedObject;
-
-    type QueryCommunities = {
-      membership?: 'all' | 'member' | 'notMember';
-      categoryId?: Amity.InternalCategory['categoryId'];
-      includeDeleted?: boolean;
-      tags?: Amity.Taggable['tags'];
-      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
-      page?: string;
-      limit?: number;
-      includeDiscoverablePrivateCommunity?: boolean;
-    };
-
-    type QueryJoinCommunity = {
-      communityId: string;
-      status: Amity.JoinRequestStatus;
-      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
-      options?: {
-        limit?: number;
-        token?: string;
-      };
-    };
-
-    type SearchQueryCommunities = {
-      displayName?: string;
-      membership?: 'all' | 'member' | 'notMember';
-      categoryId?: Amity.InternalCategory['categoryId'];
-      includeDeleted?: boolean;
-      tags?: Amity.Taggable['tags'];
-      sortBy?: Amity.SearchCommunitySortBy | Amity.SearchCommunitySortByEnum;
-      page?: string;
-      limit?: number;
-      includeDiscoverablePrivateCommunity?: boolean;
-    };
-
-    type QueryJoinRequest = {
-      communityId: string;
-      status: Amity.JoinRequestStatus;
-      targetType: 'community';
-      type: Amity.JoinRequestType;
-      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
-      options?: {
-        limit?: number;
-        token?: string;
-      };
-      page?: string;
-    };
-
-    type QueryJoinRequestList = {
-      communityIds: string[];
-      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
-      options?: {
-        limit?: number;
-        token?: string;
-      };
-      page?: string;
-    };
-
-    type CommunityLiveCollection = Amity.LiveCollectionParams<Omit<QueryCommunities, 'page'>>;
-
-    type RecommendedCommunityLiveCollection = Amity.LiveCollectionParams<{
-      limit?: number;
-      includeDiscoverablePrivateCommunity?: boolean;
-    }>;
-    type TrendingCommunityLiveCollection = Amity.LiveCollectionParams<{
-      limit?: number;
-      includeDiscoverablePrivateCommunity?: boolean;
-    }>;
-
-    type JoinRequestLiveCollection = Amity.LiveCollectionParams<QueryJoinRequest>;
-
-    type JoinRequestListLiveCollection = Amity.LiveCollectionParams<QueryJoinRequestList>;
-
-    type SearchCommunityLiveCollection = Amity.LiveCollectionParams<
-      Omit<SearchQueryCommunities, 'page'>
-    >;
-
-    type CommunityLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.Community['communityId'],
-      Pick<QueryCommunities, 'page'>
-    >;
-
-    type RecommendedCommunityLiveCollectionCache = Amity.CommunityLiveCollectionCache;
-    type TrendingCommunityLiveCollectionCache = Amity.CommunityLiveCollectionCache;
-
-    type SearchCommunityLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.Community['communityId'],
-      Pick<SearchQueryCommunities, 'page'>
-    >;
-
-    type JoinRequestLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.JoinRequest['joinRequestId'],
-      Pick<QueryJoinRequest, 'page'>
-    >;
-
-    type JoinRequestListLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.JoinRequest['joinRequestId'],
-      Pick<QueryJoinRequestList, 'page'>
-    >;
-
-    type QueryCommunityMembers = {
-      communityId: string;
-      memberships?: ('banned' | 'member')[];
-      roles?: string[];
-      sortBy?: Amity.CommunityMemberSortByEnum | Amity.CommunityMemberSortBy;
-      page?: string;
-      limit?: number;
-      includeDeleted?: boolean;
-    };
-
-    type QuerySearchCommunityMembers = {
-      communityId: string;
-      memberships?: ('banned' | 'member')[];
-      roles?: string[];
-      sortBy?: Amity.SearchCommunityMemberSortByEnum | Amity.SearchCommunityMemberSortBy;
-      search?: Amity.InternalUser['displayName'] | Amity.InternalUser['userId'];
-      page?: string;
-      limit?: number;
-      includeDeleted?: boolean;
-    };
-
-    type CommunityMemberLiveCollection = Amity.LiveCollectionParams<
-      Omit<QueryCommunityMembers, 'page'>
-    >;
-
-    type SearchCommunityMemberLiveCollection = Amity.LiveCollectionParams<
-      Omit<QuerySearchCommunityMembers, 'page'>
-    >;
-
-    type CommunityMemberLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.Membership<'community'>['userId'],
-      Pick<QueryCommunityMembers, 'page'>
-    >;
-
-    type SearchCommunityMemberLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.Community['communityId'],
-      Pick<QuerySearchCommunityMembers, 'page'>
-    >;
-
-    type QuerySemanticSearchCommunity = {
-      query: string;
-      categoryIds?: string[];
-      filter?: AmityCommunityMemberStatusFilter;
-      options?: {
-        limit?: number;
-        token?: string;
-      };
-      tags?: string[];
-      includeDiscoverablePrivateCommunity?: boolean;
-    };
-
-    type SemanticSearchCommunityLiveCollection = Amity.LiveCollectionParams<
-      Omit<QuerySemanticSearchCommunity, 'page' | 'filter' | 'options'>
-    > & {
-      communityMembershipStatus?: AmityCommunityMemberStatusFilter;
-    };
-
-    type SemanticSearchCommunityLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.Community['communityId'], // communityId:score
-      QuerySemanticSearchCommunity
-    >;
-
-    type CommunityLinkedObject = {
-      categories: Amity.Category[];
-      createInvitations: (userIds: string[]) => Promise<void>;
-      getMemberInvitations: (
-        params: Pick<Amity.InvitationLiveCollection, 'limit' | 'sortBy' | 'statuses'>,
-        callback: Amity.LiveCollectionCallback<Amity.Invitation>,
-      ) => Amity.Unsubscriber;
-      getInvitation: () => Promise<Amity.Invitation | undefined>;
-      join: () => Promise<Amity.JoinResult>;
-      getJoinRequests: (
-        params: QueryJoinRequest,
-        callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,
-      ) => Amity.Unsubscriber;
-      getMyJoinRequest: () => Promise<Amity.JoinRequest | undefined>;
-    };
-  }
-}

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

@@ -1,130 +0,0 @@
-export const ContentFeedType = Object.freeze({
-  STORY: 'story',
-  CLIP: 'clip',
-  CHAT: 'chat',
-  POST: 'post',
-  MESSAGE: 'message',
-});
-
-export enum ContentFlagReasonEnum {
-  CommunityGuidelines = 'Against community guidelines',
-  HarassmentOrBullying = 'Harassment or bullying',
-  SelfHarmOrSuicide = 'Self-harm or suicide',
-  ViolenceOrThreateningContent = 'Violence or threatening content',
-  SellingRestrictedItems = 'Selling and promoting restricted items',
-  SexualContentOrNudity = 'Sexual message or nudity',
-  SpamOrScams = 'Spam or scams',
-  FalseInformation = 'False information or misinformation',
-  Others = 'Others',
-}
-
-declare global {
-  namespace Amity {
-    type ContentFlagReason =
-      | Exclude<`${ContentFlagReasonEnum}`, `${ContentFlagReasonEnum.Others}`>
-      | (string & {});
-
-    type ContentType =
-      | 'text'
-      | 'image'
-      | 'file'
-      | 'video'
-      | 'poll'
-      | 'json'
-      | 'liveStream'
-      | 'clip'
-      | string;
-
-    type ContentFeedType = ValueOf<typeof ContentFeedType>;
-
-    type ContentDataText = {
-      title?: string | null;
-      text: string;
-    };
-
-    type ContentDataFile = {
-      fileId: Amity.File<'file'>['fileId'];
-    };
-
-    type ContentDataImage = {
-      fileId: Amity.File<'image'>['fileId'];
-      caption?: string;
-    };
-
-    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 ContentDataClip = {
-      thumbnailFileId: Amity.File<'image'>['fileId'];
-      fileId: Amity.File<'clip'>['fileId'];
-      isMuted?: boolean;
-      displayMode?: Amity.ClipDisplayMode;
-    };
-
-    type ContentDataPoll = {
-      pollId: Amity.Poll['pollId'];
-    };
-
-    type ContentDataStream = {
-      streamId: Amity.Stream['streamId'];
-    };
-
-    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 'liveStream'
-      ? ContentDataStream
-      : T extends 'clip'
-      ? ContentDataClip
-      : 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;
-  }
-}