@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

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

@@ -0,0 +1,82 @@
+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_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',
+      ManageStoryPermission = 'MANAGE_COMMUNITY_STORY',
+      CreatePrivillegedPostPermission = 'CREATE_PRIVILEGED_POST',
+    }
+
+    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;
+
+    type PermissionChecker = {
+      community: (communityId: Amity.Community['communityId']) => boolean;
+      channel: (channelId: Amity.Channel['channelId']) => boolean;
+      currentUser: () => boolean;
+    };
+  }
+}

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> & { paging?: Amity.Pagination['paging'] } & {
+              cachedAt?: Amity.CacheOptions['cachedAt'];
+            }
+        : { data: T2 } & { cachedAt?: Amity.CacheOptions['cachedAt'] }
+      : T extends Amity.Paged<infer T3, infer T4>
+      ? { data: T3[] | undefined } & Amity.Pages<T4> & { paging?: Amity.Pagination['paging'] } // paging is not existed in some collections
+      : { 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/readReceipt.ts

@@ -0,0 +1,36 @@
+export {};
+
+declare global {
+  namespace Amity {
+    const enum ReadReceiptSyncState {
+      CREATED = 'create',
+      SYNCING = 'syncing',
+    }
+
+    type ReadReceipt = {
+      channelId: Amity.Channel['channelId'];
+      latestSegment: number;
+      latestSyncSegment: number;
+    };
+
+    type ReadReceiptSyncJob = {
+      channelId: Amity.Channel['channelId'];
+      segment: number;
+      syncState: ReadReceiptSyncState;
+      retryCount: number;
+    };
+
+    type LegacyReadReceipt = {
+      subChannelId: Amity.SubChannel['subChannelId'];
+      latestSegment: number;
+      latestSyncSegment: number;
+    };
+
+    type LegacyReadReceiptSyncJob = {
+      subChannelId: Amity.SubChannel['subChannelId'];
+      segment: number;
+      syncState: ReadReceiptSyncState;
+      retryCount: number;
+    };
+  }
+}

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/ad.ts

@@ -0,0 +1,99 @@
+export {};
+
+declare global {
+  namespace Amity {
+    const enum AdPlacement {
+      FEED = 'feed',
+      STORY = 'story',
+      COMMENT = 'comment',
+      CHATLIST = 'chatlist',
+      CHAT = 'chat',
+    }
+
+    const enum SettingDisplayType {
+      Fixed = 'fixed',
+      TimeWindow = 'time-window',
+    }
+
+    type AdTarget = {
+      communityIds: Amity.Community['communityId'][];
+    };
+
+    type RawAd = {
+      adId: string;
+      advertiserId: string;
+      name: string;
+      placements: AdPlacement[];
+      headline: string;
+      description: string;
+      body: string;
+      image1_1: string;
+      image9_16: string;
+      callToAction: string;
+      callToActionUrl: string;
+      target: Amity.AdTarget;
+      startAt: Amity.timestamp;
+      endAt?: Amity.timestamp;
+      createdAt: Amity.timestamp;
+      updatedAt: Amity.timestamp;
+    };
+
+    type RawAdvertiser = {
+      advertiserId: string;
+      name: string;
+      companyName: string;
+      avatarFileId: string;
+      adsCount: number;
+      createdAt: Amity.timestamp;
+      updatedAt: Amity.timestamp;
+    };
+
+    type AdFrequency = {
+      type: Amity.SettingDisplayType;
+      value: number;
+    };
+
+    type FrequencySettings = {
+      feed?: Amity.AdFrequency;
+      story?: Amity.AdFrequency;
+      comment?: Amity.AdFrequency;
+    };
+
+    type AdsSettings = {
+      enabled: boolean;
+      maxActiveAds: number;
+      frequency: Amity.FrequencySettings;
+      updatedAt: Amity.timestamp;
+    };
+
+    type InternalAdvertiser = RawAdvertiser;
+
+    type Advertiser = RawAdvertiser & {
+      avatar?: Amity.File<'image'>;
+    };
+
+    type InternalAd = Omit<RawAd, 'endAt'> & {
+      endAt: Amity.timestamp | null;
+    };
+
+    type Ad = Omit<InternalAd, 'image1_1' | 'image9_16'> & {
+      advertiser?: Amity.Advertiser;
+      image1_1?: Amity.File<'image'>;
+      image9_16?: Amity.File<'image'>;
+      analytics: {
+        markAsSeen: (placement: Amity.AdPlacement) => void;
+        markLinkAsClicked: (placement: Amity.AdPlacement) => void;
+      };
+    };
+
+    type InternalNetworkAds = {
+      ads: Amity.InternalAd[];
+      settings: Amity.AdsSettings;
+    };
+
+    type NetworkAds = {
+      ads: Amity.Ad[];
+      settings: Amity.AdsSettings;
+    };
+  }
+}

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

@@ -0,0 +1,49 @@
+export {};
+
+declare global {
+  namespace Amity {
+    const enum AnalyticEventActivityType {
+      View = 'view',
+      Click = 'linkClicked',
+    }
+
+    const enum AnalyticEventContentType {
+      Post = 'post',
+      Story = 'story',
+      Ad = 'ad',
+    }
+
+    type AnalyticEventModel = {
+      contentId: Amity.InternalPost['postId'];
+      contentType: AnalyticEventContentType;
+      activityType: AnalyticEventActivityType;
+      timestamp: Amity.timestamp;
+      metadata?: Record<string, string>;
+    };
+
+    type AnalyticPostData = {
+      impression: number;
+      reach: number;
+    };
+
+    type QueryPostViewedUser = {
+      token?: Amity.Token;
+      limit?: Amity.PageLimit['limit'];
+    };
+
+    type ViewedUsersLiveCollection = {
+      viewedType: ValueOf<typeof AnalyticEventContentType>;
+      viewId: Amity.Post['postId'] | Amity.Story['storyId'];
+    } & Amity.LiveCollectionParams<QueryPostViewedUser>;
+
+    type PostViewedUsersLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.User['userId'],
+      {
+        page?: {
+          next?: Amity.Token;
+          previous?: Amity.Token;
+        };
+      }
+    >;
+  }
+}

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.InternalUser['userId'],
+      {
+        page: Amity.Page;
+        total: number;
+      }
+    >;
+  }
+}

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

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

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

@@ -0,0 +1,164 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type ChannelType = 'broadcast' | 'conversation' | 'community' | 'live';
+
+    type ChannelMemberActionType =
+      | 'onJoin'
+      | 'onLeft'
+      | 'onMemberRead'
+      | 'onMemberAdded'
+      | 'onMemberRemoved'
+      | 'onChannelMemberBanned'
+      | 'onChannelMemberUnbanned'
+      | 'onChannelMemberRoleAdded'
+      | 'onChannelMemberRoleRemoved';
+
+    const enum ChannelActionType {
+      OnResolveChannel = 'onResolveChannel',
+      OnResolveUnread = 'OnResolveUnread',
+      OnFetch = 'onFetch',
+      OnCreate = 'onCreate',
+      OnUpdate = 'onUpdate',
+      OnDelete = 'onDelete',
+      OnJoin = 'onJoin',
+      OnLeft = 'onLeft',
+      OnMute = 'onMute',
+      onUnmute = 'onUnmute',
+      OnMemberAdded = 'onMemberAdded',
+      OnMemberRemoved = 'onMemberRemoved',
+      OnUserMessageFeedMarkerFetch = 'onUserMessageFeedMarkerFetch',
+    }
+
+    type RawChannel<T extends ChannelType = any> = {
+      _id: string;
+      channelId: string;
+      channelInternalId: string;
+      channelPublicId: 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;
+
+      messagePreviewId?: string;
+
+      isPublic?: boolean;
+
+      lastActivity: Amity.timestamp;
+
+      attachedTo?: {
+        postId?: string;
+        videoStreamId?: string;
+      };
+    } & Amity.Metadata &
+      Amity.Taggable &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable;
+
+    // Use for the data stored in the local cache and local event payload
+    type StaticInternalChannel<T extends ChannelType = any> = RawChannel<T> & {
+      defaultSubChannelId: string;
+      isUnreadCountSupport: boolean;
+    };
+
+    /**
+     * Internal used only
+     * same as Amity.ChannelModel in tech spec
+     * It's used for the data calculated in SDK side contained dynamic values and removed unused fields
+     */
+    type InternalChannel<T extends ChannelType = any> = Omit<
+      StaticInternalChannel<T>,
+      'messageCount'
+    > & {
+      isMentioned: boolean;
+      subChannelsUnreadCount: number;
+      // legacy unread count does not use the maker service
+      unreadCount: number;
+    };
+
+    /* public type */
+    // with linked object
+    type Channel<T extends ChannelType = any> = InternalChannel<T> & {
+      messagePreview?: Amity.MessagePreview | null;
+      markAsRead: () => Promise<boolean>;
+      previewMembers: Amity.Membership<'channel'>[];
+      myMembership: (
+        callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | undefined>,
+      ) => Amity.Unsubscriber;
+    };
+
+    type QueryChannels = {
+      channelIds?: Amity.Channel['channelId'][];
+      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'];
+      limit?: number;
+      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;
+      includeDeleted?: boolean;
+    };
+
+    type SearchChannelMembers = Amity.LiveCollectionParams<Omit<QueryChannelMembers, 'sortBy'>>;
+
+    type ChannelMembersLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryChannelMembers, 'page'>
+    >;
+
+    type SearchChannelMembersLiveCollection = Amity.LiveCollectionParams<
+      Omit<SearchChannelMembers, 'page'>
+    >;
+
+    type ChannelMembersLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Membership<'channel'>['userId'],
+      Pick<QueryChannelMembers, 'page'>
+    >;
+
+    // Use for channel's unread count value stored in the local cache
+    type ChannelUnread = {
+      channelId: Amity.Channel['channelId'];
+      unreadCount: number;
+      isMentioned: boolean;
+      readToSegment: number | null;
+      lastSegment: number;
+      lastMentionedSegment: number | null;
+      isDeleted: boolean;
+    };
+  }
+}