@amityco/ts-sdk 7.6.1-1a687cb5.0 → 7.6.1-316d940a.0

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/v5/posts`, {
+  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(`/api/v4/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/v5/posts`,
+      `/api/v4/posts`,
       {
         params: {
           ...params,

package/src/postRepository/utils/payload.ts

@@ -1,8 +1,28 @@
 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, ...postPayload } = payload;
+  const { posts: postsData, postChildren, videoStreamings, ...postPayload } = payload;
 
   // Unpack community payload by mapping payload field to postSetting value.
   const communitiesWithPostSetting = addPostSetting({ communities: postPayload.communities });
@@ -24,18 +44,34 @@ 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,7 +21,10 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @async
  */
 export const createStream = async (
-  bundle: Pick<Amity.InternalStream, 'title' | 'thumbnailFileId' | 'description'> & {
+  bundle: Pick<
+    Amity.InternalStream,
+    'title' | 'thumbnailFileId' | 'description' | 'channelEnabled'
+  > & {
     isSecure?: boolean;
   },
 ): Promise<Amity.Cached<Amity.Stream>> => {

package/src/streamRepository/api/editStream.ts

@@ -0,0 +1,51 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { LinkedObject } from '~/utils/linkedObject';
+
+/* begin_public_function
+  id: stream.update
+*/
+/**
+ *
+ * ```js
+ * import { StreamRepository } from '@amityco/ts-sdk'
+ * const updated = await StreamRepository.editStream(streamId, { title: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.Stream}
+ *
+ * @param streamId The ID of the {@link Amity.Stream} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Stream} object
+ *
+ * @category Stream API
+ * @async
+ */
+
+export const editStream = async (
+  streamId: Amity.Stream['streamId'],
+  patch: Patch<
+    Amity.Stream,
+    'title' | 'thumbnailFileId' | 'description' | 'metadata' | 'channelEnabled'
+  >,
+): Promise<Amity.Cached<Amity.Stream>> => {
+  const client = getActiveClient();
+  client.log('stream/updateStream', streamId, patch);
+
+  const { data } = await client.http.put<Amity.StreamPayload>(
+    `/api/v3/video-streaming/${streamId}`,
+    patch,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { videoStreamings } = data;
+
+  return {
+    data: LinkedObject.stream(videoStreamings.find(stream => stream.streamId === streamId)!),
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/streamRepository/api/index.ts

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

package/src/streamRepository/api/updateStream.ts

@@ -7,6 +7,9 @@ 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' })
@@ -21,9 +24,13 @@ 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'>,
+  patch: Patch<
+    Amity.Stream,
+    'title' | 'thumbnailFileId' | 'description' | 'metadata' | 'channelEnabled'
+  >,
 ): Promise<Amity.Cached<Amity.Stream>> => {
   const client = getActiveClient();
   client.log('stream/updateStream', streamId, patch);

package/src/streamRepository/events/index.ts

@@ -3,3 +3,5 @@ export { onStreamStopped } from './onStreamStopped';
 export { onStreamRecorded } from './onStreamRecorded';
 export { onStreamFlagged } from './onStreamFlagged';
 export { onStreamTerminated } from './onStreamTerminated';
+export { onStreamViewerBanned } from './onStreamViewerBanned';
+export { onStreamViewerUnbanned } from './onStreamViewerUnbanned';

package/src/streamRepository/events/onStreamViewerBanned.ts

@@ -0,0 +1,58 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { mergeInCache, pullFromCache, queryCache } from '~/cache/api';
+
+/**
+ * ```js
+ * import { onStreamViewerBanned } from '@amityco/ts-sdk'
+ * const dispose = onStreamViewerBanned(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user in channel linked to stream has been banned
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamViewerBanned = (
+  callback: Amity.Listener<Amity.InternalStream>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payloads: Amity.StreamViewerBanPayload) => {
+    payloads.forEach(streamBanned => {
+      mergeInCache(['stream', 'get', streamBanned.streamId], { watcherUrl: null });
+
+      // Update isDeleted = true in banned user's messages
+      const messageCache = queryCache<Amity.InternalMessage>(['message', 'get'])?.filter(
+        // Check if creator id and user id are internal or external id
+        ({ data }) => data.creatorId === streamBanned.userId,
+      );
+
+      // Update isDeleted for each relavant messages
+      messageCache?.forEach(message => {
+        mergeInCache(message.key, { isDeleted: true });
+      });
+    });
+
+    const stream = pullFromCache<Amity.InternalStream>([
+      'stream',
+      'get',
+      payloads[0].streamId,
+    ])?.data;
+
+    if (!stream) return;
+
+    callback(stream);
+  };
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamViewerDidBan',
+    'video-streaming.viewerDidBan',
+    filter,
+  );
+};

package/src/streamRepository/events/onStreamViewerUnbanned.ts

@@ -0,0 +1,47 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { mergeInCache, pullFromCache } from '~/cache/api';
+import { getStream } from '../internalApi/getStream';
+
+/**
+ * ```js
+ * import { onStreamViewerUnbanned } from '@amityco/ts-sdk'
+ * const dispose = onStreamViewerBanned(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user in channel linked to stream has been unbanned
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamViewerUnbanned = (
+  callback: Amity.Listener<Amity.InternalStream>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = async (payloads: Amity.StreamViewerUnbanPayload) => {
+    // Get new stream object to restore stream watcherUrl in cache
+    await Promise.all(payloads.map(({ streamId }) => getStream(streamId)));
+
+    const stream = pullFromCache<Amity.InternalStream>([
+      'stream',
+      'get',
+      payloads[0].streamId,
+    ])?.data;
+
+    if (!stream) return;
+
+    callback(stream);
+  };
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamViewerDidUnban',
+    'video-streaming.viewerDidUnban',
+    filter,
+  );
+};

package/src/streamRepository/internalApi/getLiveChat.ts

@@ -0,0 +1,59 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { mergeInCache, pullFromCache } from '~/cache/api';
+import { createChannel } from '~/channelRepository/api/createChannel';
+import { channelLinkedObject } from '~/utils/linkedObject/channelLinkedObject';
+import { getChannel } from '~/channelRepository/internalApi/getChannel';
+import { constructChannelObject } from '~/channelRepository/utils/constructChannelObject';
+
+/**
+ * ```js
+ * import { getStream } from '@amityco/ts-sdk'
+ * const stream = await getStream('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Channel} object linked with a current stream
+ *
+ * @param stream {@link Amity.Stream} that has linked live channel
+ * @returns the associated {@link Amity.Channel<'live'>} object
+ *
+ * @category Stream API
+ * @async
+ */
+
+export const getLiveChat = async (
+  stream: Amity.InternalStream,
+): Promise<Amity.Channel<'live'> | undefined> => {
+  const client = getActiveClient();
+  client.log('stream/getLiveChat', stream.streamId);
+
+  if (stream.channelId) {
+    const channel = pullFromCache<Amity.StaticInternalChannel>([
+      'channel',
+      'get',
+      stream.channelId,
+    ])?.data;
+
+    if (channel) return channelLinkedObject(constructChannelObject(channel));
+
+    const { data } = await getChannel(stream.channelId);
+    return channelLinkedObject(constructChannelObject(data));
+  }
+  // No Channel ID
+  // streamer: create a new live channel
+  if (stream.userId === client.userId) {
+    const { data: channel } = await createChannel({
+      type: 'live',
+      postId: stream.referenceId,
+      videoStreamId: stream.streamId,
+    });
+
+    // Update channelId to stream object in cache
+    mergeInCache(['stream', 'get', stream.streamId], {
+      channelId: channel.channelId,
+    });
+
+    return channel;
+  }
+  // watcher: return undefined
+  return undefined;
+};

package/src/streamRepository/internalApi/getStream.ts

@@ -22,7 +22,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const getStream = async (
   streamId: Amity.Stream['streamId'],
-): Promise<Amity.Cached<Amity.Stream>> => {
+): Promise<Amity.Cached<Amity.InternalStream>> => {
   const client = getActiveClient();
   client.log('stream/getStream', streamId);
 
@@ -57,13 +57,13 @@ export const getStream = async (
  */
 getStream.locally = (
   streamId: Amity.Stream['streamId'],
-): Amity.Cached<Amity.Stream> | undefined => {
+): Amity.Cached<Amity.InternalStream> | undefined => {
   const client = getActiveClient();
   client.log('stream/getStream', streamId);
 
   if (!client.cache) return;
 
-  const cached = pullFromCache<Amity.Stream>(['stream', 'get', streamId]);
+  const cached = pullFromCache<Amity.InternalStream>(['stream', 'get', streamId]);
 
   if (!cached) return;
 

package/src/streamRepository/observers/getStreamById.ts

@@ -8,6 +8,7 @@ import { onStreamTerminated } from '~/streamRepository/events/onStreamTerminated
 import { LinkedObject } from '~/utils/linkedObject';
 import { getStream as _getStream } from '../internalApi/getStream';
 import { onStreamRecorded, onStreamStarted, onStreamStopped } from '../events';
+import { onStreamViewerBanned } from '../events/onStreamViewerBanned';
 
 /* begin_public_function
   id: stream.get
@@ -45,6 +46,7 @@ export const getStreamById = (
     onStreamStopped,
     onStreamFlagged,
     onStreamTerminated,
+    onStreamViewerBanned,
   ]);
 };
 /* end_public_function */

package/src/streamRepository/observers/getStreams/GetStreamsLiveCollectionController.ts

@@ -12,6 +12,8 @@ import {
 } from '~/streamRepository/events';
 import { GetStreamsPageController } from '~/streamRepository/observers/getStreams/GetStreamsPageController';
 import { GetStreamsQueryStreamController } from '~/streamRepository/observers/getStreams/GetStreamsQueryStreamController';
+import { onStreamViewerBanned } from '~/streamRepository/events/onStreamViewerBanned';
+import { onStreamViewerUnbanned } from '~/streamRepository/events/onStreamViewerUnbanned';
 
 export class GetStreamsLiveCollectionController extends LiveCollectionController<
   'stream',
@@ -77,6 +79,8 @@ export class GetStreamsLiveCollectionController extends LiveCollectionController
       { fn: onStreamStopped, action: 'onStreamStopped' },
       { fn: onStreamFlagged, action: 'onStreamFlagged' },
       { fn: onStreamTerminated, action: 'onStreamTerminated' },
+      { fn: onStreamViewerBanned, action: 'onStreamViewerBanned' },
+      { fn: onStreamViewerUnbanned, action: 'onStreamViewerUnbanned' },
     ]);
   }
 
@@ -102,7 +106,7 @@ export class GetStreamsLiveCollectionController extends LiveCollectionController
     this.queryStreamController.appendToQueryStream(response, direction, refresh);
   }
 
-  private applyFilter = (data: Amity.InternalStream[]): Amity.InternalStream[] => {
+  private applyFilter = (data: Amity.Stream[]): Amity.Stream[] => {
     let streams = filterByPropEquality(data, 'isDeleted', this.query.isDeleted);
 
     streams = streams.sort(

package/src/utils/linkedObject/channelLinkedObject.ts

@@ -2,6 +2,7 @@ import { markAsRead } from '~/channelRepository/internalApi/markAsRead';
 import { shallowClone } from '../shallowClone';
 import { queryCache } from '~/cache/api';
 import { channelMemberLinkedObject } from './channelMemberLinkedObject';
+import { getMyMembership } from '~/channelRepository/observers/getMyMembership';
 
 export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Channel => {
   let previewMembers: Amity.Membership<'channel'>[] = [];
@@ -23,5 +24,7 @@ export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Chann
   return shallowClone(channel, {
     markAsRead: () => markAsRead(channel.channelInternalId),
     previewMembers,
+    myMembership: (callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | undefined>) =>
+      getMyMembership(channel.channelId, callback),
   });
 };

package/src/utils/linkedObject/postLinkedObject.ts

@@ -3,16 +3,22 @@ import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
 import AnalyticsEngine from '../../analytic/service/analytic/AnalyticsEngine';
 import { userLinkedObject } from './userLinkedObject';
 import {
-  isAmityClipPost,
   isAmityFilePost,
   isAmityImagePost,
+  isAmityLivestreamPost,
+  isAmityPollPost,
   isAmityVideoPost,
 } from '../postTypePredicate';
+import { streamLinkedObject } from './streamLinkedObject';
+import { isNonNullable } from '..';
 
 export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
   return {
     ...post,
-
+    childrenPosts: post.children
+      .map(childPost => pullFromCache<Amity.InternalPost>(['post', 'get', childPost])?.data)
+      .filter(isNonNullable)
+      .map(postLinkedObject),
     analytics: {
       markAsViewed: () => {
         const analyticsEngineInstance = AnalyticsEngine.getInstance();
@@ -70,10 +76,23 @@ export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
         : undefined;
     },
 
-    getClipInfo(): Amity.File<'clip'> | undefined {
-      return isAmityClipPost(post)
-        ? pullFromCache<Amity.File<'clip'>>(['file', 'get', post?.data?.fileId])?.data
-        : undefined;
+    getLivestreamInfo(): Amity.Stream | undefined {
+      if (!isAmityLivestreamPost(post)) return;
+      const cache = pullFromCache<Amity.InternalStream>([
+        'stream',
+        'get',
+        post?.data?.streamId,
+      ])?.data;
+      if (!cache) return;
+
+      return streamLinkedObject(cache);
+    },
+
+    getPollInfo(): Amity.Poll | undefined {
+      if (!isAmityPollPost(post)) return;
+      const cache = pullFromCache<Amity.Poll>(['poll', 'get', post?.data?.pollId])?.data;
+      if (!cache) return;
+      return cache;
     },
   };
 };

package/src/utils/linkedObject/streamLinkedObject.ts

@@ -1,4 +1,5 @@
 import { pullFromCache } from '~/cache/api';
+import { getLiveChat as _getLiveChat } from '~/streamRepository/internalApi/getLiveChat';
 
 export const streamLinkedObject = (stream: Amity.InternalStream): Amity.Stream => {
   return {
@@ -18,5 +19,8 @@ export const streamLinkedObject = (stream: Amity.InternalStream): Amity.Stream =
     get user() {
       return pullFromCache<Amity.User>(['user', 'get', stream.userId])?.data;
     },
+    getLiveChat: () => _getLiveChat(stream),
+    isBanned: !stream.watcherUrl,
+    watcherUrl: null,
   };
 };

package/src/utils/postTypePredicate.ts

@@ -1,5 +1,6 @@
-export function isAmityImagePost(post: Amity.InternalPost): post is Amity.Post<'image'> {
+export function isAmityImagePost(post?: Amity.InternalPost): post is Amity.Post<'image'> {
   return !!(
+    post &&
     post.data &&
     typeof post.data !== 'string' &&
     'fileId' in post.data &&
@@ -7,8 +8,9 @@ export function isAmityImagePost(post: Amity.InternalPost): post is Amity.Post<'
   );
 }
 
-export function isAmityFilePost(post: Amity.InternalPost): post is Amity.Post<'file'> {
+export function isAmityFilePost(post?: Amity.InternalPost): post is Amity.Post<'file'> {
   return !!(
+    post &&
     post.data &&
     typeof post.data !== 'string' &&
     'fileId' in post.data &&
@@ -16,8 +18,9 @@ export function isAmityFilePost(post: Amity.InternalPost): post is Amity.Post<'f
   );
 }
 
-export function isAmityVideoPost(post: Amity.InternalPost): post is Amity.Post<'video'> {
+export function isAmityVideoPost(post?: Amity.InternalPost): post is Amity.Post<'video'> {
   return !!(
+    post &&
     post.data &&
     typeof post.data !== 'string' &&
     'videoFileId' in post.data &&
@@ -26,12 +29,22 @@ export function isAmityVideoPost(post: Amity.InternalPost): post is Amity.Post<'
   );
 }
 
-export function isAmityClipPost(post: Amity.InternalPost): post is Amity.Post<'clip'> {
+export function isAmityLivestreamPost(post?: Amity.InternalPost): post is Amity.Post<'liveStream'> {
   return !!(
+    post &&
     post.data &&
     typeof post.data !== 'string' &&
-    'fileId' in post.data &&
-    'thumbnailFileId' in post.data &&
-    post.dataType === 'clip'
+    'streamId' in post.data &&
+    post.dataType === 'liveStream'
+  );
+}
+
+export function isAmityPollPost(post?: Amity.InternalPost): post is Amity.Post<'poll'> {
+  return !!(
+    post &&
+    post.data &&
+    typeof post.data !== 'string' &&
+    'pollId' in post.data &&
+    post.dataType === 'poll'
   );
 }

package/dist/channelRepository/events/onChannelMuted.d.ts

@@ -1,2 +0,0 @@
-export declare const onChannelMuted: (callback: Amity.Listener<Amity.StaticInternalChannel>) => () => void;
-//# sourceMappingURL=onChannelMuted.d.ts.map

package/dist/channelRepository/events/onChannelMuted.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"onChannelMuted.d.ts","sourceRoot":"","sources":["../../../src/channelRepository/events/onChannelMuted.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,cAAc,aAAc,MAAM,QAAQ,CAAC,MAAM,qBAAqB,CAAC,eAgBnF,CAAC"}

package/dist/fileRepository/api/uploadClip.d.ts

@@ -1,17 +0,0 @@
-/**
- * ```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 declare const uploadClip: (formData: FormData, feedType?: Amity.ContentFeedType, onProgress?: ((percent: number) => void) | undefined) => Promise<Amity.Cached<Amity.File<'clip'>[]>>;
-//# sourceMappingURL=uploadClip.d.ts.map

package/dist/fileRepository/api/uploadClip.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uploadClip.d.ts","sourceRoot":"","sources":["../../../src/fileRepository/api/uploadClip.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,aACX,QAAQ,aACP,MAAM,eAAe,0BACT,MAAM,KAAK,IAAI,kBACrC,QAAQ,MAAM,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CA2C5C,CAAC"}

package/dist/postRepository/api/createClipPost.d.ts

@@ -1,32 +0,0 @@
-/**
- * ```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 declare const createClipPost: <T extends string>(bundle: Pick<Amity.Post<T>, "targetType" | "targetId"> & Partial<Pick<Amity.Post<T>, "metadata" | "tags" | "mentionees">> & {
-    data: {
-        [k: string]: any;
-    };
-    attachments: {
-        type: T;
-        fileId: Amity.File['fileId'];
-        displayMode?: Amity.ClipDisplayMode | undefined;
-        isMuted?: boolean | undefined;
-    }[];
-}) => Promise<Amity.Cached<Amity.Post>>;
-//# sourceMappingURL=createClipPost.d.ts.map

package/dist/postRepository/api/createClipPost.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createClipPost.d.ts","sourceRoot":"","sources":["../../../src/postRepository/api/createClipPost.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc;;;;;;gBAMX,UAAU,CAAC,QAAQ,CAAC;;;;MAKjC,QAAQ,MAAM,MAAM,CAAC,MAAM,IAAI,CAAC,CAmBlC,CAAC"}