@amityco/ts-sdk 7.6.1-2841ad2c.0 → 7.6.1-8ef2910.0

package/src/channelRepository/events/onChannelMuted.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
+
+type CallbackFn = Amity.Listener<Amity.StaticInternalChannel>;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
+export const onChannelMuted = (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payload: Amity.ChannelPayload) => {
+      const data = await prepareChannelPayload(payload);
+
+      ingestInCache(data);
+      callbacks.forEach(cb => cb(data.channels[0]));
+    };
+
+    mainDisposer = createEventSubscriber(client, 'onChannelMuted', 'channel.setMuted', filter);
+  }
+
+  callbacks.push(callback);
+  return () => dispose(callback);
+};

package/src/channelRepository/internalApi/getChannel.ts

@@ -9,6 +9,7 @@ import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 import { prepareChannelPayload } from '../utils';
 import { prepareUnreadCountInfo } from '../utils/prepareUnreadCountInfo';
+import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
 
 /**
  * ```js

package/src/channelRepository/observers/getChannel.ts

@@ -10,7 +10,7 @@ import {
   onChannelMemberBanned,
   onChannelMemberRemoved,
   onChannelMemberUnbanned,
-  onChannelSetMuted,
+  onChannelMuted,
   onChannelUpdated,
 } from '../events';
 import { dropFromCache, pullFromCache } from '~/cache/api';
@@ -104,7 +104,7 @@ export const getChannel = (
       onChannelMemberRemoved,
       onChannelMemberBanned,
       onChannelMemberUnbanned,
-      onChannelSetMuted,
+      onChannelMuted,
       convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
       convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
       convertEventPayload(

package/src/channelRepository/observers/getChannels/ChannelLiveCollectionController.ts

@@ -11,6 +11,7 @@ import {
   onChannelLeft,
   onChannelMemberAdded,
   onChannelMemberRemoved,
+  onChannelMuted,
   onChannelUpdated,
 } from '~/channelRepository/events';
 import {
@@ -57,7 +58,6 @@ import { onUserMessageFeedMarkerResolved } from '~/marker/events/onUserMessageFe
 import { onChannelUnreadInfoUpdatedLocal } from '~/marker/events/onChannelUnreadInfoUpdatedLocal';
 import { constructChannelObject } from '~/channelRepository/utils/constructChannelObject';
 import { onChannelUnreadUpdatedLocal } from '~/channelRepository/events/onChannelUnreadUpdatedLocal';
-import { onChannelSetMuted } from '~/channelRepository/events/onChannelSetMuted';
 
 export class ChannelLiveCollectionController extends LiveCollectionController<
   'channel',
@@ -313,7 +313,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       },
       { fn: onChannelDeleted, action: Amity.ChannelActionType.OnDelete },
       { fn: onChannelUpdated, action: Amity.ChannelActionType.OnUpdate },
-      { fn: onChannelSetMuted, action: Amity.ChannelActionType.OnMute },
+      { fn: onChannelMuted, action: Amity.ChannelActionType.OnMute },
       {
         fn: (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
           return onChannelJoined(channel => {

package/src/channelRepository/utils/constructChannelObject.ts

@@ -1,6 +1,6 @@
 import { getChannelMessagePreviewWithUser } from '~/messagePreview/utils';
 import { constructChannelDynamicValue } from './constructChannelDynamicValue';
-import { channelLinkedObject } from '~/utils/linkedObject/channelLinkedObject';
+import { LinkedObject } from '~/utils/linkedObject';
 
 export const constructChannelObject = (channel: Amity.StaticInternalChannel): Amity.Channel => {
   /**
@@ -10,7 +10,7 @@ export const constructChannelObject = (channel: Amity.StaticInternalChannel): Am
    * 3. [LinkedObject.channel] add markAsRead >> Amity.InternalChannel -> Amity.Channel
    */
 
-  return channelLinkedObject(
+  return LinkedObject.channel(
     constructChannelDynamicValue(getChannelMessagePreviewWithUser(channel)),
   );
 };

package/src/client/api/login.ts

@@ -13,7 +13,6 @@ import analyticsEngineOnLoginHandler from '~/analytic/utils/analyticsEngineOnLog
 import readReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler';
 import legacyReadReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngineOnLoginHandler';
 import objectResolverEngineOnLoginHandler from '~/client/utils/ObjectResolver/objectResolverEngineOnLoginHandler';
-import reactionSyncEngineOnLoginHandler from '~/liveReactionRepository/utils/ReactionSyncEngineOnLoginHandler';
 import { logout } from './logout';
 
 import { getActiveClient } from './activeClient';
@@ -202,7 +201,6 @@ export const login = async (
       markReadEngineOnLoginHandler(),
       analyticsEngineOnLoginHandler(),
       objectResolverEngineOnLoginHandler(),
-      reactionSyncEngineOnLoginHandler(),
     );
 
     if (client.useLegacyUnreadCount) {

package/src/communityRepository/api/getCommunity.ts

@@ -5,7 +5,6 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload } from '../utils';
-import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -23,8 +22,6 @@ import { LinkedObject } from '~/utils/linkedObject';
  */
 export const getCommunity = async (
   communityId: Amity.Community['communityId'],
-  type?: Amity.JoinRequestType,
-  includeDiscoverablePrivateCommunity?: boolean,
 ): Promise<Amity.Cached<Amity.InternalCommunity>> => {
   const client = getActiveClient();
   client.log('community/getCommunity', communityId);
@@ -32,12 +29,6 @@ export const getCommunity = async (
   // API-FIX: endpoint should not be /list, parameters should be querystring.
   const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/${communityId}`,
-    {
-      params: {
-        type: 'communityJoinRequest',
-        includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
-      },
-    },
   );
 
   const data = prepareCommunityPayload(payload);

package/src/core/events.ts

@@ -32,10 +32,7 @@ const MQTT_EVENTS = [
   'video-streaming.didFlag',
   'video-streaming.didTerminate',
 
-  'video-streaming.viewerDidBan',
-  'video-streaming.viewerDidUnban',
-
-  'liveReaction.created',
+  // 'user.didGlobalBan' remove due to message event,
 ] as const;
 
 /** @hidden */

package/src/core/subscription.ts

@@ -154,16 +154,6 @@ export const getSmartFeedMessageTopic = (): string => {
   return `${getNetworkId(user)}/smartfeed/${user._id}/messages`;
 };
 
-export const getLiveStreamTopic = (): string => {
-  const user = getActiveUser();
-
-  return `${getNetworkId(user)}/videostreaming`;
-};
-
-export const getLiveReactionTopic = (post: Amity.Post) => {
-  return `${post.path}/liveReaction`;
-};
-
 let mqttAccessToken: string;
 let mqttUserId: string;
 
@@ -178,3 +168,9 @@ export function subscribeTopic(
 
   return mqtt.subscribe(topic, callback);
 }
+
+export const getLiveStreamTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/videostreaming`;
+};

package/src/feedRepository/api/getCustomRankingGlobalFeed.ts

@@ -23,7 +23,7 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @async
  * */
 export const getCustomRankingGlobalFeed = async (query?: {
-  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
+  dataTypes?: ('video' | 'image' | 'file' | 'liveStream' | 'clip')[];
   limit?: number;
   queryToken?: string;
 }): Promise<

package/src/feedRepository/api/queryGlobalFeed.ts

@@ -32,7 +32,7 @@ export const queryGlobalFeed = async (
   const client = getActiveClient();
   client.log('feed/queryGlobalFeed', query);
 
-  const { queryToken, ...params } = query ?? {};
+  const { queryToken, dataTypes, resolveParent, ...params } = query ?? {};
 
   const options = (() => {
     if (queryToken) return { token: queryToken };
@@ -44,6 +44,8 @@ export const queryGlobalFeed = async (
     {
       params: {
         ...params,
+        dataTypes,
+        resolveParent: resolveParent ?? true,
         options,
       },
     },

package/src/fileRepository/api/index.ts

@@ -5,3 +5,4 @@ export * from './fileUrlWithSize';
 export * from './uploadVideo';
 export * from './uploadImage';
 export * from './updateAltText';
+export * from './uploadClip';

package/src/fileRepository/api/uploadClip.ts

@@ -0,0 +1,71 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import GlobalFileAccessType from '~/client/utils/GlobalFileAccessType';
+
+/* begin_public_function
+  id: file.upload.clip
+*/
+/**
+ * ```js
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const created = await FileRepository.uploadClip(formData)
+ * ```
+ *
+ * Creates an {@link Amity.File}
+ *
+ * @param formData The data necessary to create a new {@link Amity.File}
+ * @param onProgress The callback to track the upload progress
+ * @returns The newly created {@link Amity.File}
+ *
+ * @category File API
+ * @async
+ */
+export const uploadClip = async (
+  formData: FormData,
+  feedType?: Amity.ContentFeedType,
+  onProgress?: (percent: number) => void,
+): Promise<Amity.Cached<Amity.File<'clip'>[]>> => {
+  const client = getActiveClient();
+  client.log('file/uploadClip', formData);
+
+  const file = formData.get('files');
+
+  if (!file) throw new Error('The formData object must have a `files` key.');
+
+  const accessType = GlobalFileAccessType.getInstance().getFileAccessType();
+  formData.append('accessType', accessType);
+
+  formData.append('preferredFilename', (file as File).name);
+
+  if (feedType) {
+    formData.append('feedType', feedType);
+  }
+
+  const headers =
+    'getHeaders' in formData
+      ? (formData as any).getHeaders()
+      : { 'content-type': 'multipart/form-data' };
+
+  const { data } = await client.upload.post<Amity.CreateFilePayload<'clip'>>(
+    '/api/v4/clips',
+    formData,
+    {
+      headers,
+      onUploadProgress({ loaded, total = 100 }) {
+        onProgress && onProgress(Math.round((loaded * 100) / total));
+      },
+    },
+  );
+
+  // API-FIX: payload should be serialized properly
+  // const { files } = data
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: data }, { cachedAt });
+
+  return {
+    data,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/index.ts

@@ -53,5 +53,3 @@ export * from './external/api';
 export * as notificationTray from './notificationTray';
 
 export * as InvitationRepository from './invitationRepository';
-
-export * as LiveReactionRepository from './liveReactionRepository';

package/src/liveStreamPlayer/api/getPlayer.ts

@@ -60,7 +60,7 @@ export const getPlayer = async (parameters: { streamId: string }): Promise<HTMLV
     video.src = recording.mp4.url;
   }
 
-  new EventRegister(video, resolution, streamId).registerEvents();
+  new EventRegister(video, resolution).registerEvents();
 
   return video;
 };

package/src/liveStreamPlayer/utils/eventRegister.ts

@@ -1,6 +1,5 @@
 import uuid from 'react-native-uuid';
 import { getUsageCollector } from '../api/getUsageCollector';
-import { onStreamViewerBanned } from '~/streamRepository/events';
 
 const SECOND = 1000;
 /*
@@ -33,9 +32,7 @@ export class EventRegister {
 
   _observer: MutationObserver;
 
-  _SDKUnsubscribers: Amity.Unsubscriber[] = [];
-
-  constructor(player: HTMLVideoElement, resolution: string, streamId: string) {
+  constructor(player: HTMLVideoElement, resolution: string) {
     this.player = player;
     this.resolution = resolution;
     this._startTime = null;
@@ -56,22 +53,10 @@ export class EventRegister {
         mutation.removedNodes.forEach(node => {
           if (node === player) {
             this._unregisterEvents();
-            this._SDKUnsubscribers.forEach(fn => fn?.());
           }
         });
       });
     });
-
-    this._SDKUnsubscribers.push(
-      onStreamViewerBanned(stream => {
-        // if still has stream.watcherUrl, the current user has not banned.
-        if (stream.watcherUrl) return;
-        this.player.pause();
-        this.player.removeAttribute('src');
-        this.player.load();
-        this.player.remove();
-      }),
-    );
   }
 
   _resetStartTime() {

package/src/messageRepository/api/deleteMessage.ts

@@ -23,22 +23,6 @@ export const deleteMessage = async (
   const client = getActiveClient();
   client.log('message/deleteMessage', messageId);
 
-  if (messageId.includes('LOCAL_')) {
-    const message = pullFromCache<Amity.InternalMessage>(['message', 'get', messageId])?.data;
-    if (!message) throw Error('messageId not found');
-
-    const deletedMessage = {
-      ...message,
-      isDeleted: true,
-    };
-
-    fireEvent('local.message.deleted', {
-      messages: [deletedMessage],
-    });
-
-    return LinkedObject.message(deletedMessage);
-  }
-
   // API-FIX: This endpoint has not been implemented yet.
   const { data: deleted } = await client.http.delete<Amity.MessagePayload>(
     `/api/v5/messages/${encodeURIComponent(messageId)}`,

package/src/messageRepository/observers/getMessage.ts

@@ -11,7 +11,6 @@ import {
   onMessageReactionAdded,
   onMessageReactionRemoved,
 } from '../events';
-import { onStreamViewerBanned } from '~/streamRepository/events/onStreamViewerBanned';
 import { onMessageFetched } from '../events/onMessageFetched';
 import { LinkedObject } from '~/utils/linkedObject';
 
@@ -58,7 +57,6 @@ export const getMessage = (
     onMessageReactionRemoved,
     convertEventPayload(onMessageMarkerFetched, 'contentId', 'message'),
     convertEventPayload(onMessageMarked, 'contentId', 'message'),
-    convertEventPayload(onStreamViewerBanned, 'channelId', 'message'),
   ]);
 };
 /* end_public_function */

package/src/messageRepository/observers/getMessages/MessageLiveCollectionController.ts

@@ -11,7 +11,6 @@ import {
   onMessageUnflagged,
   onMessageUpdated,
 } from '~/messageRepository/events';
-import { onStreamViewerBanned } from '~/streamRepository/events/onStreamViewerBanned';
 import { convertEventPayload } from '~/utils/event';
 import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
 import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
@@ -71,7 +70,6 @@ export class MessageLiveCollectionController extends LiveCollectionController<
         action: 'onUpdate',
       },
       { fn: convertEventPayload(onMessageMarked, 'contentId', 'message'), action: 'onUpdate' },
-      { fn: convertEventPayload(onStreamViewerBanned, 'channelId', 'message'), action: 'onUpdate' },
     ]);
   }
 

package/src/messageRepository/observers/getMessages/MessageQueryStreamController.ts

@@ -116,19 +116,6 @@ export class MessageQueryStreamController extends QueryStreamController<
         pushToCache(this.cacheKey, collection);
       }
 
-      if (action === 'onDelete' && payload.syncState === Amity.SyncState.Error) {
-        const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
-        if (!collection) return;
-
-        if (collection.data.includes(payload.messageId)) {
-          const newCollectionData = collection.data.filter(
-            messageId => messageId !== payload.messageId,
-          );
-
-          pushToCache(this.cacheKey, { ...collection, data: newCollectionData });
-        }
-      }
-
       this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
     };
   }

package/src/postRepository/api/createClipPost.ts

@@ -0,0 +1,62 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+import { LinkedObject } from '~/utils/linkedObject';
+
+/* begin_public_function
+  id: post.create.clip_post
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const created = await PostRepository.createClipPost({
+ *   targetType: 'user',
+ *   targetId: 'foobar',
+ *   dataType: 'clip',
+ *   data: { text: 'hello world' },
+ *   attachments: [{ type: 'clip', fileId: 'fileId123', displayMode: 'fill', isMuted: false }]
+ * }))
+ * ```
+ *
+ * Creates an {@link Amity.Post}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Post}
+ * @returns The newly created {@link Amity.Post}
+ *
+ * @category Post API
+ * @async
+ */
+export const createClipPost = async <T extends Amity.PostContentType | string>(
+  bundle: Pick<Amity.Post<T>, 'targetType' | 'targetId'> &
+    Partial<Pick<Amity.Post<T>, 'metadata' | 'mentionees' | 'tags'>> & {
+      data: { [k: string]: any };
+      attachments: {
+        type: T;
+        fileId: Amity.File['fileId'];
+        displayMode?: Amity.ClipDisplayMode;
+        isMuted?: boolean;
+      }[];
+    },
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('post/createPost', bundle);
+
+  const { data: payload } = await client.http.post<Amity.PostPayload>('/api/v4/posts', bundle);
+
+  fireEvent('post.created', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { posts } = data;
+
+  return {
+    data: LinkedObject.post(posts[0]),
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/postRepository/api/createPost.ts

@@ -2,8 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 import { LinkedObject } from '~/utils/linkedObject';
-import { preparePostPayload } from '../utils/payload';
 
 /* begin_public_function
   id: post.create.text_post, post.create.image_post, post.create.file_post, post.create.video_post, post.create.poll_post, post.create.livestream_post, post.create.custom_post
@@ -46,8 +46,7 @@ export const createPost = async <T extends Amity.PostContentType | string>(
 
   fireEvent('post.created', payload);
 
-  const data = preparePostPayload(payload);
-
+  const data = prepareMembershipPayload(payload, 'communityUsers');
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/postRepository/api/index.ts

@@ -13,3 +13,5 @@ export * from './declinePost';
 export * from './flagPost';
 export * from './unflagPost';
 export * from './isPostFlaggedByMe';
+
+export * from './createClipPost';

package/src/postRepository/api/queryPosts.ts

@@ -43,7 +43,7 @@ export const queryPosts = async (
   // API-FIX: parameters should be querystring. (1)
   // API-FIX: backend should answer Amity.Response (2)
   // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<Amity.PostPayload>>>(
-  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(`/api/v4/posts`, {
+  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(`/api/v5/posts`, {
     params: {
       ...params,
       isDeleted: inferIsDeleted(includeDeleted),

package/src/postRepository/observers/getPosts/PostPaginationController.ts

@@ -23,7 +23,7 @@ export class PostPaginationController extends PaginationController<
     const options = token ? { ...baseOptions, token } : { ...baseOptions, limit };
 
     const { data: queryResponse } = await this.http.get<Amity.PostPayload & Amity.Pagination>(
-      `/api/v4/posts`,
+      `/api/v5/posts`,
       {
         params: {
           ...params,

package/src/postRepository/utils/payload.ts

@@ -1,28 +1,8 @@
 import { addPostSetting } from '~/communityRepository/utils';
 import { updateMembershipStatus } from '~/communityRepository/utils/communityWithMembership';
-import { isAmityLivestreamPost } from '~/utils/postTypePredicate';
-
-const updateStreamReferences = (
-  streams: Amity.RawStream[],
-  streamId: string | undefined,
-  postId: string,
-) => {
-  if (!streamId) return streams;
-
-  return streams.map(stream =>
-    stream.streamId === streamId
-      ? {
-          ...stream,
-          referenceType: 'post',
-          referenceId: postId,
-          postId,
-        }
-      : stream,
-  );
-};
 
 export const preparePostPayload = (payload: Amity.PostPayload): Amity.ProcessedPostPayload => {
-  const { posts: postsData, postChildren, videoStreamings, ...postPayload } = payload;
+  const { posts: postsData, ...postPayload } = payload;
 
   // Unpack community payload by mapping payload field to postSetting value.
   const communitiesWithPostSetting = addPostSetting({ communities: postPayload.communities });
@@ -44,34 +24,18 @@ export const preparePostPayload = (payload: Amity.PostPayload): Amity.ProcessedP
     mappedCommunityUsers,
   );
 
-  let mappedNewStream: Amity.RawStream[] = [];
-
   // feed type
   const posts = postsData.map(post => {
     const feedType = postPayload.feeds.find(feed => feed.feedId === post.feedId)?.feedType;
-    const childPosts = payload.postChildren.filter(
-      children => children.parentPostId === post.postId,
-    );
-
-    if (childPosts.length > 0 && isAmityLivestreamPost(childPosts[0])) {
-      mappedNewStream = updateStreamReferences(
-        videoStreamings,
-        childPosts[0].data?.streamId,
-        post.postId,
-      );
-    }
 
     return {
       ...post,
-      childPosts,
       feedType,
     };
   });
 
   return {
     ...postPayload,
-    postChildren,
-    videoStreamings: mappedNewStream,
     posts,
     communities: communityWithMembershipStatus,
     communityUsers: mappedCommunityUsers,

package/src/streamRepository/api/createStream.ts

@@ -21,10 +21,7 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @async
  */
 export const createStream = async (
-  bundle: Pick<
-    Amity.InternalStream,
-    'title' | 'thumbnailFileId' | 'description' | 'channelEnabled'
-  > & {
+  bundle: Pick<Amity.InternalStream, 'title' | 'thumbnailFileId' | 'description'> & {
     isSecure?: boolean;
   },
 ): Promise<Amity.Cached<Amity.Stream>> => {

package/src/streamRepository/api/index.ts

@@ -2,4 +2,3 @@ export * from './createStream';
 export * from './updateStream';
 export * from './deleteStream';
 export * from './disposeStream';
-export * from './editStream';

package/src/streamRepository/api/updateStream.ts

@@ -7,9 +7,6 @@ import { LinkedObject } from '~/utils/linkedObject';
   id: stream.update
 */
 /**
- * @deprecated this function is deprecated,
- * please use {@link Amity.StreamRepository.editStream} instead.
- *
  * ```js
  * import { updateStream } from '@amityco/ts-sdk'
  * const updated = await updateStream(streamId, { title: 'foobar' })
@@ -24,13 +21,9 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @category Stream API
  * @async
  */
-
 export const updateStream = async (
   streamId: Amity.Stream['streamId'],
-  patch: Patch<
-    Amity.Stream,
-    'title' | 'thumbnailFileId' | 'description' | 'metadata' | 'channelEnabled'
-  >,
+  patch: Patch<Amity.Stream, 'title' | 'thumbnailFileId' | 'description' | 'metadata'>,
 ): Promise<Amity.Cached<Amity.Stream>> => {
   const client = getActiveClient();
   client.log('stream/updateStream', streamId, patch);