@amityco/ts-sdk 0.0.1-beta.16 → 0.0.1-beta.17

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

@@ -1,37 +1,41 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type ContentType = ('text' | 'image' | 'file' | 'video' | 'json' | string)
+    type ContentType = 'text' | 'image' | 'file' | 'video' | 'json' | string;
 
     type ContentDataText = {
-      text: string
-    }
+      text: string;
+    };
 
     type ContentDataFile = {
-      fileId: Amity.File<'file'>['fileId']
-    }
+      fileId: Amity.File<'file'>['fileId'];
+    };
 
     type ContentDataImage = {
-      imageId: Amity.File<'image'>['fileId']
-    }
+      imageId: Amity.File<'image'>['fileId'];
+    };
 
     type ContentDataVideo = {
-      videoId: Amity.File<'file'>['fileId']
-    }
+      videoId: Amity.File<'file'>['fileId'];
+    };
 
-    type ContentData<T extends ContentType> = (
-      T extends 'text'  ? ContentDataText :
-      T extends 'file'  ? ContentDataFile :
-      T extends 'image' ? ContentDataImage :
-      T extends 'video' ? ContentDataVideo :
-      T extends 'json'  ? Record<string, unknown> :
-      T extends string  ? string | Record<string, unknown> : // custom type
-      never
-    )
+    type ContentData<T extends ContentType> = T extends 'text'
+      ? ContentDataText
+      : T extends 'file'
+      ? ContentDataFile
+      : T extends 'image'
+      ? ContentDataImage
+      : T extends 'video'
+      ? ContentDataVideo
+      : T extends 'json'
+      ? Record<string, unknown>
+      : T extends string
+      ? string | Record<string, unknown> // custom type
+      : never;
 
-    type Content<T extends ContentType, K extends 'type' | 'dataType' = 'dataType'> = (
-      { [S in K]?: T } & { data: ContentData<T> }
-    )
+    type Content<T extends ContentType, K extends 'type' | 'dataType' = 'dataType'> = {
+      [S in K]?: T;
+    } & { data: ContentData<T> };
   }
 }

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

@@ -1,16 +1,15 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type FeedType = ('community' | 'user')
+    type FeedType = 'community' | 'user';
 
     type Feed = {
-      feedId: string
-      feedType: 'reviewing' | 'published'
-      targetType: FeedType
-      targetId: string
-      postCount: number
-    }
-    & Amity.Timestamps
+      feedId: string;
+      feedType: 'reviewing' | 'published';
+      targetType: FeedType;
+      targetId: string;
+      postCount: number;
+    } & Amity.Timestamps;
   }
 }

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

@@ -1,41 +1,41 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type FileType = 'file' | 'image' | 'video'
+    type FileType = 'file' | 'image' | 'video';
 
-    type FileMetadata = {}
+    type FileMetadata = Record<string, never>;
 
     type ImageMetadata = {
-      exif: Object
-      gps: Object
-      width: number
-      height: number
-      isFull:	boolean
-    }
+      exif: Record<string, unknown>;
+      gps: Record<string, unknown>;
+      width: number;
+      height: number;
+      isFull: boolean;
+    };
 
-    type VideoMetadata = {}
+    type VideoMetadata = Record<string, never>;
 
-    type MetadataFor<T extends FileType> = (
-      T extends 'file' ? FileMetadata :
-      T extends 'image' ? ImageMetadata :
-      T extends 'video' ? VideoMetadata :
-      never
-    )
+    type MetadataFor<T extends FileType> = T extends 'file'
+      ? FileMetadata
+      : T extends 'image'
+      ? ImageMetadata
+      : T extends 'video'
+      ? VideoMetadata
+      : never;
 
     type File<T extends FileType = any> = {
-      fileId:	string
-      type: T
-      fileUrl: string
+      fileId: string;
+      type: T;
+      fileUrl: string;
       attributes: {
-        name: string
-        extension: string
-        size: string
-        mimeType: string
-        metadata: MetadataFor<T>
-      }
-    }
-    & Amity.Timestamps
-    & Amity.SoftDelete
+        name: string;
+        extension: string;
+        size: string;
+        mimeType: string;
+        metadata: MetadataFor<T>;
+      };
+    } & Amity.Timestamps &
+      Amity.SoftDelete;
   }
 }

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

@@ -1,25 +1,23 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
     type FollowStatus = {
-      from: Amity.User['userId']
-      to: Amity.User['userId']
-      status: 'pending' | 'accepted' | 'none'
-    }
-    & Amity.CreatedAt
-    & Amity.UpdatedAt
+      from: Amity.User['userId'];
+      to: Amity.User['userId'];
+      status: 'pending' | 'accepted' | 'none';
+    } & Amity.CreatedAt &
+      Amity.UpdatedAt;
 
     type FollowCount = {
-      userId: Amity.User['userId']
-      followerCount: number
-      followingCount: number
-      pendingCount: number
-    }
+      userId: Amity.User['userId'];
+      followerCount: number;
+      followingCount: number;
+      pendingCount: number;
+    };
 
     type FollowInfo = {
-      status?: FollowStatus['status']
-    }
-    & FollowCount
+      status?: FollowStatus['status'];
+    } & FollowCount;
   }
 }

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

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

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

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

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

@@ -1,27 +1,26 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type MessageContentType = ('text' | 'file' | 'image')
+    type MessageContentType = 'text' | 'file' | 'image';
 
     type Message<T extends Amity.MessageContentType = any> = {
-      messageId: string
+      messageId: string;
 
-      channelId: Amity.Channel['channelId']
-      userId: Amity.User['userId']
+      channelId: Amity.Channel['channelId'];
+      userId: Amity.User['userId'];
 
-      parentId?: Message['messageId']
-      childrenNumber: number
+      parentId?: Message['messageId'];
+      childrenNumber: number;
 
-      channelSegment: number
+      channelSegment: number;
 
-      editedAt: timestamp
-    }
-    & Amity.Content<T, 'type'>
-    & Amity.Metadata
-    & Amity.Timestamps
-    & Amity.SoftDelete
-    & Amity.Reactable
-    & Amity.Mentionable<'user' | 'channel'>
+      editedAt: Amity.timestamp;
+    } & Amity.Content<T, 'type'> &
+      Amity.Metadata &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Reactable &
+      Amity.Mentionable<'user' | 'channel'>;
   }
 }

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

@@ -1,56 +1,56 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type timestamp = string
+    type timestamp = string;
 
     type CreatedAt = {
-      createdAt: timestamp
-    }
+      createdAt: timestamp;
+    };
 
     type UpdatedAt = {
-      updatedAt?: timestamp
-    }
+      updatedAt?: timestamp;
+    };
 
     type DeletedAt = {
-      deletedAt?: timestamp
-    }
+      deletedAt?: timestamp;
+    };
 
-    type Timestamps = CreatedAt & UpdatedAt
+    type Timestamps = CreatedAt & UpdatedAt;
 
     type SoftDelete = DeletedAt & {
-      isDeleted?: boolean
-    }
+      isDeleted?: boolean;
+    };
 
     type Metadata = {
-      metadata?: Record<string, any>
-    }
+      metadata?: Record<string, any>;
+    };
 
     type Relationship<T extends string> = {
-      referenceId: string
-      referenceType: T
-    }
+      referenceId: string;
+      referenceType: T;
+    };
 
     type Flaggable = {
-      flagCount: number
+      flagCount: number;
       hashFlag: {
-        bits: number
-        hashes: number
-        hash: string
-      } | null
-    }
+        bits: number;
+        hashes: number;
+        hash: string;
+      } | null;
+    };
 
     type Taggable = {
-      tags?: string[]
-    }
+      tags?: string[];
+    };
 
     type Accredited = {
-        roles: Amity.Role['displayName'][]
-        permissions: Amity.Permission[]
-    }
+      roles: Amity.Role['displayName'][];
+      permissions: Amity.Permission[];
+    };
 
     type Subscribable = {
-      path: string
-    }
+      path: string;
+    };
   }
 }

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

@@ -1,33 +1,33 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
     // bad hack until we get proper feed objects in backend
-    type PostTargetType = Amity.FeedType | 'content'
+    type PostTargetType = Amity.FeedType | 'content';
 
-    type PostContentType = ('text' | 'image' | 'file' | 'video')
+    type PostContentType = 'text' | 'image' | 'file' | 'video';
 
     type Post<T extends PostContentType = any> = {
-      postId: string
-      postedUserId: User['userId'] // API-FIX: it should be "userId"
-      parentId: Post['postId']
-      targetType: PostTargetType
-      targetId: string
-      feedId: Feed['feedId']
-      children: Amity.Post['postId'][]
-      comments: Amity.Comment['commentId'][]
-      commentsCount: number // API-FIX: backend doesnt follow its own convention
-      hasFlaggedChildren: false
-      hasFlaggedComment: false
-      editedAt: timestamp,
-    }
-    & Amity.Content<T, 'dataType'>
-    & Amity.Metadata
-    & Amity.Flaggable
-    & Amity.Reactable
-    & Amity.Timestamps
-    & Amity.SoftDelete
-    & Amity.Subscribable
-    & Amity.Mentionable<'user'>
+      postId: string;
+      postedUserId: Amity.User['userId']; // API-FIX: it should be "userId"
+      parentId: Post['postId'];
+      targetType: PostTargetType;
+      targetId: string;
+      feedId: Amity.Feed['feedId'];
+      children: Amity.Post['postId'][];
+      comments: Amity.Comment['commentId'][];
+      commentsCount: number; // API-FIX: backend doesnt follow its own convention
+      hasFlaggedChildren: false;
+      hasFlaggedComment: false;
+      editedAt: Amity.timestamp;
+    } & Amity.Content<T, 'dataType'> &
+      Amity.Metadata &
+      Amity.Flaggable &
+      Amity.Reactable &
+      Amity.Taggable &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Mentionable<'user'>;
   }
 }

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

@@ -1,30 +1,29 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type ReactableType = ('message' | 'post' | 'comment')
+    type ReactableType = 'message' | 'post' | 'comment';
 
-    type Reaction =  {
-      reactionId: string
-      userId: string
-      reactionName: string
-    }
-    & Amity.CreatedAt
-    & Amity.Relationship<ReactableType>
+    type Reaction = {
+      reactionId: string;
+      userId: string;
+      reactionName: string;
+    } & Amity.CreatedAt &
+      Amity.Relationship<ReactableType>;
 
     type Reactions = {
-      reactions: Record<string, number>
-      count: number
-    }
+      reactions: Record<string, number>;
+      count: number;
+    };
 
     type Reactable = {
-      reactionsCount: number
-      reactions: Record<string, number>
-      myReactions?: string[]
+      reactionsCount: number;
+      reactions: Record<string, number>;
+      myReactions?: string[];
 
       latestReaction?: Amity.Reaction & {
-        eventName: ('added' | 'removed')
-      }
-    }
+        eventName: 'added' | 'removed';
+      };
+    };
   }
 }

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

@@ -1,4 +1,4 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
@@ -16,53 +16,52 @@ declare global {
     }
 
     type MultiFormat<T> = {
-      flv?: T
-      mp4?: T
-      m3u8?: T
-    }
+      flv?: T;
+      mp4?: T;
+      m3u8?: T;
+    };
 
     type StreamPlatform = {
-      name: string
-      version: string
-    }
+      name: string;
+      version: string;
+    };
 
     type StreamEndpoint = {
-      url: string
+      url: string;
       components: {
-        origin: string
-        appName: string
-        streamName: string
-        query: string
-      }
-    }
+        origin: string;
+        appName: string;
+        streamName: string;
+        query: string;
+      };
+    };
 
     type StreamRecording = {
-      url: string
-      duration: number
-      startTime: number
-      stopTime: number
-    }
+      url: string;
+      duration: number;
+      startTime: number;
+      stopTime: number;
+    };
 
     type Stream = {
-      streamId: string
-      title: string
-      thumbnailFileId?: Amity.File<'image'>['fileId']
-      description?: string
-      status: StreamStatus
-      platform: StreamPlatform
+      streamId: string;
+      title: string;
+      thumbnailFileId?: Amity.File<'image'>['fileId'];
+      description?: string;
+      status: StreamStatus;
+      platform: StreamPlatform;
 
-      isLive?: boolean
-      endedAt: timestamp
-      startedAt: timestamp
-      userId: User['userId']
-      resolution: StreamResolution
+      isLive?: boolean;
+      endedAt: Amity.timestamp;
+      startedAt: Amity.timestamp;
+      userId: Amity.User['userId'];
+      resolution: StreamResolution;
 
-      streamerUrl: StreamEndpoint
-      watcherUrl: MultiFormat<StreamEndpoint>
-      recordings: MultiFormat<StreamRecording>[]
-    }
-    & Amity.Metadata
-    & Amity.Timestamps
-    & Amity.SoftDelete
+      streamerUrl: StreamEndpoint;
+      watcherUrl: MultiFormat<StreamEndpoint>;
+      recordings: MultiFormat<StreamRecording>[];
+    } & Amity.Metadata &
+      Amity.Timestamps &
+      Amity.SoftDelete;
   }
 }

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

@@ -1,19 +1,19 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
     type User = {
-      _id: string
-      userId: string
-      displayName?: string
-      avatarFileId?: Amity.File<'image'>['fileId']
-      description?: string
-    }
-    & Amity.Metadata
-    & Amity.Taggable
-    & Amity.Flaggable
-    & Amity.Accredited
-    & Amity.Timestamps
-    & Amity.Subscribable
+      _id: string;
+      userId: string;
+      displayName?: string;
+      avatarFileId?: Amity.File<'image'>['fileId'];
+      avatarCustomUrl?: string;
+      description?: string;
+    } & Amity.Metadata &
+      Amity.Taggable &
+      Amity.Flaggable &
+      Amity.Accredited &
+      Amity.Timestamps &
+      Amity.Subscribable;
   }
 }