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

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

@@ -0,0 +1,81 @@
+export {};
+
+export enum AmityEventType {
+  Virtual = 'virtual',
+  InPerson = 'in_person',
+}
+
+export enum AmityEventOriginType {
+  Community = 'community',
+  User = 'user',
+}
+
+export enum AmityEventStatus {
+  Scheduled = 'scheduled',
+  Live = 'live',
+  Ended = 'ended',
+  Cancelled = 'cancelled',
+}
+
+declare global {
+  namespace Amity {
+    type EventType = AmityEventType;
+
+    type EventOriginType = AmityEventOriginType;
+
+    type EventStatus = AmityEventStatus;
+
+    type RawEvent = {
+      eventId: string;
+      userId: string;
+      publicId: string;
+      title: string;
+      description: string;
+      type: Amity.EventType;
+      status: Amity.EventStatus;
+      isInviteOnly: boolean;
+      startTime: Date;
+      endTime?: Date;
+      coverImageUrl: string;
+      originType: Amity.EventOriginType;
+      originId: string;
+      communityId?: string;
+      livestreamId?: string;
+      rsvpCount: number;
+      interestedCount: number;
+      isLocationVisible: boolean;
+      location?: string;
+      externalUrl?: string;
+    } & Amity.Taggable &
+      Amity.Metadata &
+      Amity.Timestamps &
+      Amity.SoftDelete;
+
+    type InternalEvent = RawEvent;
+
+    type Event = Amity.InternalEvent & Amity.EventLinkObject;
+
+    type EventLinkObject = {
+      discussionCommunity?: Amity.Community;
+      liveStream?: Amity.Stream;
+      creator?: Amity.User;
+    };
+
+    type EventCreateOptions = Pick<
+      Amity.Event,
+      | 'title'
+      | 'description'
+      | 'type'
+      | 'isInviteOnly'
+      | 'startTime'
+      | 'endTime'
+      | 'originType'
+      | 'originId'
+      | 'location'
+      | 'externalUrl'
+      | 'tags'
+    > & {
+      coverImageFileId?: string;
+    };
+  }
+}

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

@@ -0,0 +1,78 @@
+export {};
+
+export const enum FeedDataTypeEnum {
+  Text = 'text',
+  Video = 'video',
+  Image = 'image',
+  File = 'file',
+  LiveStream = 'liveStream',
+  Clip = 'clip',
+  Poll = 'poll',
+}
+
+export const enum FeedSortByEnum {
+  LastCreated = 'lastCreated',
+  FirstCreated = 'firstCreated',
+  LastUpdated = 'lastUpdated',
+  FirstUpdated = 'firstUpdated',
+}
+
+export const enum FeedSourceEnum {
+  Community = 'community',
+  User = 'user',
+}
+
+declare global {
+  namespace Amity {
+    type FeedDataType = FeedDataTypeEnum;
+
+    type FeedSortBy = FeedSortByEnum;
+
+    type FeedSource = FeedSourceEnum;
+
+    type Feed = {
+      feedId: string;
+      feedType: 'reviewing' | 'published';
+      targetType: Extract<Amity.Domain, 'community' | 'user'>;
+      targetId: string;
+      postCount: number;
+    } & Amity.Timestamps;
+
+    type QueryGlobalFeed = {
+      dataTypes?: ('video' | 'image' | 'file' | 'liveStream' | 'clip')[];
+      queryToken?: string;
+    };
+
+    type CustomRankingGlobalFeedLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryGlobalFeed, 'resolveParent' | 'queryToken'>
+    >;
+
+    type CustomRankingGlobalFeedLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalPost['postId'],
+      QueryGlobalFeed
+    >;
+
+    type GlobalFeedLiveCollection = Amity.LiveCollectionParams<Omit<QueryGlobalFeed, 'queryToken'>>;
+
+    type GlobalFeedLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalPost['postId'],
+      QueryGlobalFeed
+    >;
+
+    type QueryUserFeed = {
+      userId: string;
+      includeDeleted?: boolean;
+      sortBy?: Amity.FeedSortBy;
+      dataTypes?: Amity.FeedDataType[];
+      matchingOnlyParentPost?: boolean;
+      feedSources?: Amity.FeedSource[];
+    };
+
+    type UserFeedLiveCollection = Amity.LiveCollectionParams<QueryUserFeed>;
+
+    type UserFeedLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalPost['postId'],
+      QueryUserFeed
+    >;
+  }
+}

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

@@ -0,0 +1,73 @@
+export const FileType = Object.freeze({
+  FILE: 'file',
+  IMAGE: 'image',
+  VIDEO: 'video',
+  CLIP: 'clip',
+});
+
+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',
+});
+
+export enum FileAccessTypeEnum {
+  PUBLIC = 'public',
+  NETWORK = 'network',
+}
+
+declare global {
+  namespace Amity {
+    type FileAccessType = `${FileAccessTypeEnum}`;
+
+    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 ClipMetadata = Record<string, never>;
+
+    type MetadataFor<T extends FileType> = T extends 'file'
+      ? FileMetadata
+      : T extends 'image'
+      ? ImageMetadata
+      : T extends 'video'
+      ? VideoMetadata
+      : T extends 'clip'
+      ? ClipMetadata
+      : never;
+
+    type File<T extends FileType = any> = Amity.FilePayload<T>;
+  }
+}

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

@@ -0,0 +1,67 @@
+export {};
+
+declare global {
+  namespace Amity {
+    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;
+      followingCount: number;
+      pendingCount: number;
+    };
+
+    type FollowInfo = {
+      status?: FollowStatus['status'];
+    } & FollowCount;
+
+    type QueryFollowers = {
+      userId: Amity.InternalUser['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,51 @@
+export {};
+
+declare global {
+  namespace Amity {
+    enum GroupTypeEnum {
+      CHANNEL = 'channel',
+      COMMUNITY = 'community',
+    }
+    type GroupType = `${GroupTypeEnum}`;
+    type GroupMembership = 'member' | 'none' | 'banned' | 'muted';
+
+    type Group = {
+      membersCount: number;
+    };
+
+    type Member<T extends Amity.GroupType> = {
+      userId: Amity.InternalUser['userId'];
+      userInternalId: Amity.InternalUser['userInternalId'];
+      userPublicId: Amity.InternalUser['userPublicId'];
+    } & (T extends 'channel'
+      ? {
+          channelId: Amity.Channel['channelId'];
+          membership: GroupMembership;
+          readToSegment: number;
+          lastMentionedSegment: number;
+        }
+      : T extends 'community'
+      ? {
+          communityId: Amity.Community['communityId'];
+          communityMembership: GroupMembership;
+        }
+      : never) &
+      Amity.Timestamps;
+
+    type MemberWithUser<T extends Amity.GroupType> = Member<T> & {
+      readonly user?: Amity.InternalUser;
+    };
+
+    type RawMembership<T extends Amity.GroupType> = {
+      isBanned: boolean;
+      isMuted: boolean;
+      muteTimeout: string;
+      lastActivity: Amity.timestamp;
+    } & Amity.Member<T> &
+      Amity.Accredited;
+
+    type Membership<T extends Amity.GroupType> = Amity.RawMembership<T> & {
+      readonly user?: Amity.InternalUser;
+    };
+  }
+}

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

@@ -0,0 +1,11 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type Hashtag = {
+      text: string;
+      index: number;
+      length: number;
+    };
+  }
+}

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

@@ -0,0 +1,119 @@
+export {};
+
+export const enum InvitationTypeEnum {
+  CommunityMemberInvite = 'communityMemberInvite',
+  LivestreamInvite = 'livestreamInvite',
+}
+
+export const enum InvitationStatusEnum {
+  Pending = 'pending',
+  Approved = 'approved',
+  Rejected = 'rejected',
+  Cancelled = 'cancelled',
+}
+
+export const enum InvitationSortByEnum {
+  FirstCreated = 'firstCreated',
+  LastCreated = 'lastCreated',
+}
+
+declare global {
+  namespace Amity {
+    type InvitationType = InvitationTypeEnum;
+
+    type InvitationStatus = InvitationStatusEnum;
+
+    type InvitationTargetType = Extract<Amity.Domain, 'community'>;
+
+    type InvitationTargetMap = {
+      community: Amity.InternalCommunity;
+    };
+
+    type InvitationTarget<T extends InvitationTargetType> = InvitationTargetMap[T];
+
+    type InvitationSortBy = InvitationSortByEnum;
+
+    type InvitationDomain<T extends Amity.InvitationTargetType = Amity.InvitationTargetType> =
+      T extends 'community' ? { communityId: string } : { communityId?: string };
+
+    type RawInvitation = {
+      _id: string;
+      networkId: string;
+      type: Amity.InvitationType;
+      targetId: string;
+      targetType: Amity.InvitationTargetType;
+      userId: string;
+      status: Amity.InvitationStatus;
+      respondedAt: Amity.timestamp;
+      createdBy: string;
+      invitationId: string;
+      invitedUserId: string;
+      invitedUserInternalId: string;
+      invitedUserPublicId: string;
+      inviterUserId: string;
+      inviterUserInternalId: string;
+      inviterUserPublicId: string;
+    } & Amity.Timestamps &
+      Amity.InvitationDomain<Amity.InvitationTargetType>;
+
+    type InternalInvitation = Omit<RawInvitation, 'createdBy'> & {
+      createdById: string;
+    };
+
+    type Invitation = Omit<Amity.InternalInvitation, 'createdBy'> &
+      Amity.InvitationLinkedObject & {
+        user?: Amity.User;
+        createdById: string;
+        createdBy?: Amity.User;
+        target?: Amity.InvitationTarget<Amity.InvitationTargetType>;
+      };
+
+    type QueryInvitations = {
+      targetId: string;
+      statuses?: string[];
+      token?: Amity.Token;
+      type: Amity.InvitationType;
+      sortBy?: Amity.InvitationSortBy;
+      limit?: Amity.PageLimit['limit'];
+      targetType: Amity.InvitationTargetType;
+    };
+
+    type InvitationLiveCollection = Amity.LiveCollectionParams<Omit<QueryInvitations, 'limit'>>;
+
+    type InvitationLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalInvitation['_id'],
+      Pick<QueryInvitations, 'limit'>
+    >;
+
+    type QueryMyInvitations = {
+      targetId?: string;
+      token?: Amity.Token;
+      type?: Amity.InvitationType;
+      sortBy?: Amity.InvitationSortBy;
+      limit?: Amity.PageLimit['limit'];
+      statuses?: InvitationStatusEnum[];
+      targetType?: Amity.InvitationTargetType;
+    };
+
+    type MyInvitationsLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryMyInvitations, 'limit'>
+    >;
+
+    type MyInvitationsLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalInvitation['_id'],
+      Pick<QueryMyInvitations, 'limit'>
+    >;
+
+    type InvitationLinkedObject = {
+      accept: () => Promise<void>;
+      reject: () => Promise<void>;
+    };
+
+    type CreateInvitations = {
+      type: Amity.InvitationType;
+      targetType: Amity.InvitationTargetType;
+      targetId: string;
+      userIds: string[];
+    };
+  }
+}

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

@@ -0,0 +1,66 @@
+export {};
+
+export const enum JoinRequestStatusEnum {
+  Pending = 'pending',
+  Approved = 'approved',
+  Rejected = 'rejected',
+  Cancelled = 'cancelled',
+}
+
+export const enum JoinResultStatusEnum {
+  Success = 'success',
+  Pending = 'pending',
+}
+
+declare global {
+  namespace Amity {
+    type JoinRequestStatus = JoinRequestStatusEnum;
+
+    type JoinResultStatus = JoinResultStatusEnum;
+
+    type JoinRequestType = 'communityJoinRequest';
+
+    type JoinResult = {
+      status: Amity.JoinResultStatus;
+      request?: Amity.JoinRequest;
+    };
+
+    type RawJoinRequest = {
+      _id: string;
+      createdAt: Amity.timestamp;
+      joinRequestId: string;
+      networkId: string;
+
+      requestorId: string;
+      requestorInternalId: string;
+      requestorPublicId: string;
+
+      respondedAt: Amity.timestamp | null;
+      responderId: string | null;
+      responderInternalId: string | null;
+      responderPublicId: string | null;
+
+      status: Amity.JoinRequestStatus;
+      targetId: string;
+      targetType: string;
+      type: Amity.JoinRequestType;
+      updatedAt: Amity.timestamp;
+      userId: string;
+    };
+
+    type InternalJoinRequest = Omit<RawJoinRequest, '_id'>;
+
+    type JoinRequest = Omit<Amity.InternalJoinRequest, 'responderId'> &
+      Amity.JoinRequestLinkedObject & {
+        user?: Amity.User;
+        feeds?: Amity.Feed[];
+        files?: Amity.File[];
+      };
+
+    type JoinRequestLinkedObject = {
+      cancel: () => Promise<void>;
+      approve: () => Promise<void>;
+      reject: () => Promise<void>;
+    };
+  }
+}

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

@@ -0,0 +1,25 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type RawLiveReaction = {
+      userId: string; // user's public ID
+      referenceId: string; // post's internal ID
+      referencePublicId: string; // post's public ID
+      referenceType: string; // 'post'
+      reactionName: string; // 'love
+      // date string in ISO format
+      occurredAt: string;
+    };
+
+    type InternalLiveReaction = RawLiveReaction;
+
+    type LiveReaction = InternalLiveReaction;
+
+    type CreateLiveReactionRequest = Omit<RawLiveReaction, 'userId' | 'referenceId' | 'occurredAt'>;
+
+    type CreateLiveReactionResponse = {
+      addedIds: string[];
+    };
+  }
+}

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

@@ -0,0 +1,14 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type UsageDataModel = {
+      sessionId: string;
+      streamId: string;
+      startTime: string;
+      endTime: string;
+      watchSeconds: number;
+      resolution: string;
+    };
+  }
+}

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

@@ -0,0 +1,37 @@
+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',
+    }
+
+    type ChannelUnreadInfo = {
+      channelId: Amity.RawChannel['channelId'];
+      unreadCount: number;
+      isMentioned: boolean;
+    } & Amity.Timestamps;
+
+    type SubChannelUnreadInfo = {
+      subChannelId: Amity.RawSubChannel['messageFeedId'];
+      channelId: Amity.RawChannel['channelId'];
+      readToSegment: number;
+      lastSegment: number;
+      lastMentionSegment: number;
+      unreadCount: number;
+      isMentioned: boolean;
+      isDeleted: boolean;
+    } & Amity.Timestamps;
+  }
+}

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][];
+    };
+  }
+}