@amityco/ts-sdk 7.1.1-ce25d503.0 → 7.1.1-e23f973a.0

package/src/notificationTray/api/markItemsSeen.ts

@@ -0,0 +1,59 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: notificationTrayItem.markSeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const updated = await notificationTray.markItemsSeen()
+ * ```
+ *
+ * Updates an {@link Amity.NotificationItemSeen}
+ *
+ * @param trayItems[] that include id and lastTraySeenAt, The ID of the {@link Amity.NotificationItemSeen} to edit
+ * @returns the updated {@link Amity.NotificationItemSeen} object
+ *
+ * @category NotificationItemSeen API
+ * @async
+ */
+export const markItemsSeen = async (patch: Amity.QueryNotificationItemSeen) => {
+  const client = getActiveClient();
+  client.log('notificationTray/markItemsSeen', {});
+
+  const { data: payload } = await client.http.put<Amity.RawNotificationTraySeenUpdated>(
+    `api/v1/notification-tray/items/seen`,
+    {
+      patch,
+    },
+  );
+
+  const updatedData = patch.trayItems
+    .map(patchItem => {
+      const cacheData = pullFromCache<Amity.InternalNotificationTrayItem>([
+        'notificationTraySeen',
+        'get',
+        patchItem.id,
+      ])?.data;
+
+      if (!cacheData) return;
+
+      const data = {
+        ...cacheData,
+        ...payload,
+      };
+
+      if (client.cache) {
+        const cachedAt = Date.now();
+        pushToCache(['notificationTrayItem', 'get'], data, { cachedAt });
+      }
+
+      return data;
+    })
+    .filter(Boolean) as Amity.InternalNotificationTrayItem[];
+
+  fireEvent('local.notificationTrayItem.updated', { notificationTrayItems: updatedData });
+};
+/* end_public_function */

package/src/notificationTray/api/markTraySeen.ts

@@ -0,0 +1,65 @@
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: notificationTray.markSeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const updated = await notificationTray.markTraySeen({
+ *   lastSeenAt: Amity.timestamp,
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.NotificationTraySeen}
+ *
+ * @param userId The ID of the {@link Amity.NotificationTraySeen} to edit
+ * @param lastSeenAt The patch data to apply
+ * @returns the updated {@link Amity.NotificationTraySeen} object
+ *
+ * @category Post API
+ * @async
+ */
+export const markTraySeen = async (
+  lastSeenAt: Amity.timestamp,
+): Promise<Amity.Cached<Amity.NotificationTraySeenUpdatedPayload>> => {
+  const client = getActiveClient();
+  client.log('notificationTray/markTraySeen', {});
+
+  const { data: payload } = await client.http.put<Amity.NotificationTraySeenUpdatedPayload>(
+    `api/v1/notification-tray/tray/seen`,
+    {
+      lastSeenAt,
+    },
+  );
+
+  const cacheData = pullFromCache<Amity.InternalNotificationTraySeen>([
+    'notificationTraySeen',
+    'get',
+  ])?.data;
+
+  const data = {
+    userId: client.userId!,
+    ...payload,
+  } as Amity.InternalNotificationTraySeen;
+
+  const updateCacheData = {
+    ...cacheData,
+    ...data,
+  };
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache)
+    pushToCache(['notificationTraySeen', 'get', client.userId!], updateCacheData, { cachedAt });
+
+  fireEvent('local.notificationTraySeen.updated', data);
+
+  return {
+    data: payload,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/notificationTray/events/index.ts

@@ -0,0 +1 @@
+export * from './onNotificationTraySeenUpdated';

package/src/notificationTray/events/onNotificationTraySeenUpdated.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onNotificationTraySeenUpdated } from '@amityco/ts-sdk'
+ * const dispose = onNotificationTraySeenUpdated(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.NotificationTraySeen} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category NotificationTraySeen Events
+ */
+export const onNotificationTraySeenUpdated = (
+  callback: Amity.Listener<Amity.InternalNotificationTraySeen>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const disposers = [
+    createEventSubscriber(
+      client,
+      'onNotificationTraySeenUpdated',
+      'local.notificationTraySeen.updated',
+      payload => callback(payload),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/notificationTray/index.ts

@@ -0,0 +1,3 @@
+export * from './observers';
+export * from './api';
+export * from './events';

package/src/notificationTray/internalApi/getNotificationTraySeen.ts

@@ -0,0 +1,81 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: notificationTray.getNotificationTraySeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const notificationTraySeen = await notificationTray.getNotificationTraySeen()
+ * ```
+ *
+ *
+ * @returns A page of {@link Amity.NotificationTraySeen} objects
+ *
+ * @category NotificationTray API
+ * @async
+ * */
+export const getNotificationTraySeen = async (): Promise<
+  Amity.Cached<Amity.NotificationTraySeen>
+> => {
+  const client = getActiveClient();
+  client.log('notificationTray/getNotificationTraySeen', {});
+
+  const { data: payload } = await client.http.get<Amity.NotificationTraySeenPayload>(
+    `api/v1/notification-tray/tray/seen`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    const cacheKey = ['notificationTraySeen', 'get', client.userId];
+    pushToCache(cacheKey, {
+      userId: client.userId,
+      lastTraySeenAt: payload.lastTraySeenAt,
+      lastTrayOccuredAt: payload.lastTrayOccuredAt,
+    });
+  }
+
+  return {
+    data: {
+      userId: client.userId!,
+      lastTraySeenAt: payload.lastTraySeenAt,
+      lastTrayOccuredAt: payload.lastTrayOccuredAt,
+      isSeen: payload.lastTraySeenAt > payload.lastTrayOccuredAt,
+    },
+    cachedAt,
+  };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const notificationTraySeen = await notificationTray.getNotificationTraySeen.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.NotificationTraySeen} objects from cache
+ *
+ * @returns A page of {@link Amity.NotificationTraySeen} objects
+ *
+ * @category NotificationTray API
+ * @async
+ * */
+getNotificationTraySeen.locally = ():
+  | Amity.Cached<Amity.NotificationTraySeenPayload>
+  | undefined => {
+  const client = getActiveClient();
+  client.log('notificationTray/getNotificationTraySeen.locally', {});
+
+  if (!client.cache) return;
+
+  const queryKey = ['notificationTraySeen', 'get'];
+
+  const { data, cachedAt } =
+    pullFromCache<{ notificationTraySeen: Amity.NotificationTraySeenPayload }>(queryKey) ?? {};
+
+  if (!data?.notificationTraySeen) return;
+
+  return { data: data.notificationTraySeen, cachedAt };
+};

package/src/notificationTray/observers/getNotificationTrayItems/NotificationTrayItemsLiveCollectionController.ts

@@ -0,0 +1,96 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { NotificationTrayItemsPaginationController } from './NotificationTrayItemsPaginationController';
+import { NotificationTrayItemsQuerystreamController } from './NotificationTrayItemsQuerystreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { prepareNotificationTrayItemsPayload } from '~/notificationTray/utils/prepareNotificationTrayItemsPayload';
+import { isNonNullable } from '~/utils';
+import { LinkedObject } from '~/utils/linkedObject';
+
+export class NotificationTrayItemsLiveCollectionController extends LiveCollectionController<
+  'notificationTrayItem',
+  Amity.NotificationTrayItemLiveCollection,
+  Amity.NotificationTrayItem,
+  NotificationTrayItemsPaginationController
+> {
+  private queryStreamController: NotificationTrayItemsQuerystreamController;
+
+  private query: Amity.NotificationTrayItemLiveCollection;
+
+  constructor(
+    query: Amity.NotificationTrayItemLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.NotificationTrayItem>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['notificationTrayItem', 'collection', queryStreamId];
+    const paginationController = new NotificationTrayItemsPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new NotificationTrayItemsQuerystreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareNotificationTrayItemsPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.NotificationTrayItemLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.NotificationTrayPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'notificationTrayItem'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  startSubscription() {
+    return [] as Amity.Unsubscriber[];
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.NotificationTrayItemLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) return;
+
+    const data = (
+      collection.data
+        .map(id =>
+          pullFromCache<Amity.InternalNotificationTrayItem>(['notificationTrayItem', 'get', id]),
+        )
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? []
+    ).map(LinkedObject.notificationTray);
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+}

package/src/notificationTray/observers/getNotificationTrayItems/NotificationTrayItemsPaginationController.ts

@@ -0,0 +1,31 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class NotificationTrayItemsPaginationController extends PaginationController<
+  'notificationTrayItem',
+  Amity.NotificationTrayItemLiveCollection
+> {
+  async getRequest(
+    queryParams: Amity.NotificationTrayItemLiveCollection,
+    token: string | undefined,
+  ) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<
+      Amity.NotificationTrayPayload & Amity.Pagination
+    >(`/api/v1/notification-tray`, {
+      params: {
+        ...params,
+        options,
+      },
+    });
+
+    return queryResponse;
+  }
+}

package/src/notificationTray/observers/getNotificationTrayItems/NotificationTrayItemsQuerystreamController.ts

@@ -0,0 +1,68 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+
+export class NotificationTrayItemsQuerystreamController extends QueryStreamController<
+  Amity.NotificationTrayPayload,
+  Amity.NotificationTrayItemLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.NotificationTrayPayload,
+  ) => Amity.ProcessedNotificationTrayPayload;
+
+  constructor(
+    query: Amity.NotificationTrayItemLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.NotificationTrayPayload,
+    ) => Amity.ProcessedNotificationTrayPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.NotificationTrayPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.NotificationTrayPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.notificationTrayItems.map(getResolver('notificationTrayItem')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.NotificationTrayItemLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+
+      const notifications = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([
+            ...notifications,
+            ...response.notificationTrayItems.map(getResolver('notificationTrayItem')),
+          ]),
+        ],
+      });
+    }
+  }
+}

package/src/notificationTray/observers/getNotificationTrayItems.ts

@@ -0,0 +1,44 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { NotificationTrayItemsLiveCollectionController } from './getNotificationTrayItems/NotificationTrayItemsLiveCollectionController';
+
+/**
+ * Get notification tray items for a notification tray page
+ *
+ * @param params the limit query parameters
+ * @param callback the callback to be called when the notification tray items are updated
+ * @returns items in the notification tray
+ *
+ * @category Notification tray items Live Collection
+ *
+ */
+export const getNotificationTrayItems = (
+  params: Amity.LiveCollectionParams<Amity.NotificationTrayItemLiveCollection>,
+  callback: Amity.LiveCollectionCallback<Amity.NotificationTrayItem>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getNotificationTrayItems(tmpid: ${timestamp}) > listen`);
+
+  const notiTrayItemsLiveCollection = new NotificationTrayItemsLiveCollectionController(
+    params,
+    callback,
+  );
+  const disposers = notiTrayItemsLiveCollection.startSubscription();
+
+  const cacheKey = notiTrayItemsLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getNotificationTrayItems(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/notificationTray/observers/getNotificationTraySeen.ts

@@ -0,0 +1,43 @@
+import { liveObject } from '~/utils/liveObject';
+import { getNotificationTraySeen as _getNotificationTraySeen } from '../internalApi/getNotificationTraySeen';
+import { onNotificationTraySeenUpdated } from '../events/onNotificationTraySeenUpdated';
+import { getActiveUser } from '~/client';
+
+/* begin_public_function
+  id: notificationTraySeen.get
+*/
+/**
+ * ```js
+ * import { getNotificationTraySeen } from '@amityco/ts-sdk';
+ *
+ * let notificationTraySeen;
+ *
+ * const unsubscribe = getNotificationTraySeen(userId, response => {
+ *   notificationTraySeen = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.NotificationTraySeen}
+ *
+ * @param userId the ID of the user to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the message
+ *
+ * @category NotificationTraySeen Live Object
+ */
+export const getNotificationTraySeen = (
+  callback: Amity.LiveObjectCallback<Amity.NotificationTraySeenPayload>,
+): Amity.Unsubscriber => {
+  const responder: Amity.LiveObjectCallback<Amity.InternalNotificationTraySeen> = (
+    snapshot: Amity.LiveObject<Amity.InternalNotificationTraySeen>,
+  ) => {
+    const { data } = snapshot;
+    callback({ ...snapshot, data });
+  };
+
+  const { userId } = getActiveUser();
+  return liveObject(userId, responder, 'userId', _getNotificationTraySeen, [
+    onNotificationTraySeenUpdated,
+  ]);
+};
+/* end_public_function */

package/src/notificationTray/observers/index.ts

@@ -0,0 +1,2 @@
+export * from './getNotificationTraySeen';
+export * from './getNotificationTrayItems';

package/src/notificationTray/utils/prepareNotificationTrayItemsPayload.ts

@@ -0,0 +1,12 @@
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
+
+export const prepareNotificationTrayItemsPayload = (
+  rawPayload: Amity.NotificationTrayPayload,
+): Amity.ProcessedNotificationTrayPayload => {
+  const users = rawPayload.users.map(convertRawUserToInternalUser);
+
+  return {
+    ...rawPayload,
+    users,
+  };
+};

package/src/utils/linkedObject/index.ts

@@ -10,6 +10,7 @@ import { reactorLinkedObject } from './reactorLinkedObject';
 import { channelLinkedObject } from './channelLinkedObject';
 import { adLinkedObject } from './adLinkedObject';
 import { pinnedPostLinkedObject } from './pinnedPostLinkedObject';
+import { notificationTrayLinkedObject } from './notificationTrayLinkedObject';
 
 export const LinkedObject = {
   ad: adLinkedObject,
@@ -24,4 +25,5 @@ export const LinkedObject = {
   reactor: reactorLinkedObject,
   channel: channelLinkedObject,
   pinnedPost: pinnedPostLinkedObject,
+  notificationTray: notificationTrayLinkedObject,
 };

package/src/utils/linkedObject/notificationTrayLinkedObject.ts

@@ -0,0 +1,19 @@
+import { pullFromCache } from '~/cache/api';
+import { isNonNullable } from '..';
+import { WEEK } from '../constants';
+import { userLinkedObject } from './userLinkedObject';
+
+export const notificationTrayLinkedObject = (
+  noti: Amity.InternalNotificationTrayItem,
+): Amity.NotificationTrayItem => {
+  return {
+    ...noti,
+    isSeen: noti.lastSeenAt > noti.lastOccurredAt,
+    isRecent: new Date(noti.lastOccurredAt).getTime() >= Date.now() - WEEK,
+    users: noti.actors
+      .map(({ _id }) => pullFromCache<Amity.InternalUser>(['user', 'get', _id])!)
+      .filter(isNonNullable)
+      .map(({ data }) => data)
+      .map(user => userLinkedObject(user)),
+  };
+};

package/dist/channelRepository/api/markChannelsAsReadBySegment.d.ts

@@ -1,16 +0,0 @@
-/**
- *
- * Mark subChannel as read by readToSegment
- *
- * @param subChannelIds the IDs of the {@link Amity.SubChannel} to update
- * @param readToSegment the segment to mark as read
- * @returns a success boolean if the {@link Amity.SubChannel} was updated
- *
- * @category Channel API
- * @async
- */
-export declare const markChannelsAsReadBySegment: (readings: {
-    channelId: Amity.Channel['channelId'];
-    readToSegment: number;
-}[]) => Promise<boolean>;
-//# sourceMappingURL=markChannelsAsReadBySegment.d.ts.map

package/dist/channelRepository/api/markChannelsAsReadBySegment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markChannelsAsReadBySegment.d.ts","sourceRoot":"","sources":["../../../src/channelRepository/api/markChannelsAsReadBySegment.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,2BAA2B,aAC5B;IACR,SAAS,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAC;IACtC,aAAa,EAAE,MAAM,CAAC;CACvB,EAAE,KACF,QAAQ,OAAO,CASjB,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"onChannelUnreadUpdatedLocal.d.ts","sourceRoot":"","sources":["../../../src/channelRepository/events/onChannelUnreadUpdatedLocal.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,aAC5B,MAAM,QAAQ,CAAC,MAAM,MAAM,CAAC,6BAA6B,CAAC,CAAC,KACpE,MAAM,YAaR,CAAC"}

package/dist/channelRepository/internalApi/getTotalChannelsUnread.d.ts

@@ -1,11 +0,0 @@
-/**
- *
- * Calculate user unread from {@link Amity.ChannelUnread} objects
- *
- * @returns the {@link Amity.UserUnread} objects
- *
- * @category Channel API
- * @async
- */
-export declare const getTotalChannelsUnread: () => Amity.Cached<Amity.UserUnread>;
-//# sourceMappingURL=getTotalChannelsUnread.d.ts.map

package/dist/channelRepository/internalApi/getTotalChannelsUnread.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getTotalChannelsUnread.d.ts","sourceRoot":"","sources":["../../../src/channelRepository/internalApi/getTotalChannelsUnread.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AAEH,eAAO,MAAM,sBAAsB,QAAO,MAAM,MAAM,CAAC,MAAM,UAAU,CAwBtE,CAAC"}

package/dist/channelRepository/observers/getTotalChannelsUnread.d.ts

@@ -1,20 +0,0 @@
-/**
- * ```js
- * import { ChannelRepository } from '@amityco/ts-sdk';
- *
- * let totalChannelsUnread;
- *
- * const unsubscribe = ChannelRepository.getTotalChannelsUnread(response => {
- *   unread = response.data;
- * });
- * ```
- *
- * Observe all mutation on a given {@link Amity.UserUnread}
- *
- * @returns An {@link Amity.UserUnread} function to run when willing to stop observing the message
- *
- * @category User Unread Live Object
- *
- */
-export declare const getTotalChannelsUnread: (callback: Amity.LiveObjectCallback<Amity.UserUnread | undefined>) => Amity.Unsubscriber;
-//# sourceMappingURL=getTotalChannelsUnread.d.ts.map

package/dist/channelRepository/observers/getTotalChannelsUnread.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getTotalChannelsUnread.d.ts","sourceRoot":"","sources":["../../../src/channelRepository/observers/getTotalChannelsUnread.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;GAiBG;AAEH,eAAO,MAAM,sBAAsB,aACvB,MAAM,kBAAkB,CAAC,MAAM,UAAU,GAAG,SAAS,CAAC,KAC/D,MAAM,YA2FR,CAAC"}

package/dist/channelRepository/utils/getLegacyChannelUnread.d.ts

@@ -1,2 +0,0 @@
-export declare const getLegacyChannelUnread: (channelId: string) => Amity.ChannelUnreadInfo | undefined;
-//# sourceMappingURL=getLegacyChannelUnread.d.ts.map

package/dist/channelRepository/utils/getLegacyChannelUnread.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getLegacyChannelUnread.d.ts","sourceRoot":"","sources":["../../../src/channelRepository/utils/getLegacyChannelUnread.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB,cAAe,MAAM,wCAEvD,CAAC"}