@amityco/ts-sdk 6.12.2-d74459e.0 → 6.12.2-e855934.0

package/src/streamRepository/api/getStreams.ts

@@ -23,7 +23,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 export const getStreams = async (query?: {
   isLive?: boolean;
   statuses?: Amity.StreamStatus[];
-  userPublicIds?: Amity.User['userId'][];
+  userPublicIds?: Amity.InternalUser['userId'][];
   sortBy?: 'lastCreated' | 'firstCreated';
   isDeleted?: Amity.Stream['isDeleted'];
   page?: Amity.Page;

package/src/streamRepository/api/queryStreams.ts

@@ -23,7 +23,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 export const queryStreams = async (query?: {
   isLive?: boolean;
   statuses?: Amity.StreamStatus[];
-  userPublicIds?: Amity.User['userId'][];
+  userPublicIds?: Amity.InternalUser['userId'][];
   sortBy?: 'lastCreated' | 'firstCreated';
   isDeleted?: Amity.Stream['isDeleted'];
   page?: Amity.Page;

package/src/subChannelRepository/observers/tests/getSubChannels.test.ts

@@ -10,6 +10,7 @@ import {
 import { getFutureDate, getPastDate } from '~/core/model';
 import * as getSubChannelMarkers from '~/marker/api/getSubChannelMarkers';
 import { getSubChannels } from '../getSubChannels';
+import { ASCApiError } from '~/core/errors';
 
 describe('getSubChannels', () => {
   const rawSubChannel = generateRawSubChannel();
@@ -61,26 +62,28 @@ describe('getSubChannels', () => {
     );
   });
 
-  test('should filter deleted sub channels based on params', async () => {
-    const rawSubChannels = [
-      generateRawSubChannel({ isDeleted: true }),
-      generateRawSubChannel({ messageFeedId: 'sub-channel-id-2' }),
-    ];
+  test('should error when get invalid sub channels', async () => {
     const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue({
-      data: {
-        messageFeeds: rawSubChannels,
-        messages: [],
-        users: [],
-        files: [],
-        paging: {},
-      },
-    });
 
-    getSubChannels({ channelId: rawSubChannel.channelPublicId, includeDeleted: false }, callback);
+    const error = new ASCApiError(
+      'Channel not found.',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    getSubChannels({ channelId: rawSubChannel.channelPublicId }, callback);
     await pause();
 
     expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        data: [],
+        loading: true,
+      }),
+    );
     expect(callback).toHaveBeenNthCalledWith(
       2,
       expect.objectContaining({
@@ -88,6 +91,7 @@ describe('getSubChannels', () => {
           return { ...subChannel, messagePreview: null };
         }),
         loading: false,
+        error,
       }),
     );
   });
@@ -151,6 +155,295 @@ describe('getSubChannels', () => {
     );
   });
 
+  test('when querying two subchannel collections with same channelId but different params, pagination remains functional', async () => {
+    const subChannelCase1Page1 = [
+      generateRawSubChannel({ channelPublicId: 'channel1', name: '1' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: '2' }),
+    ];
+    const subChannelCase1Page2 = [
+      generateRawSubChannel({ channelPublicId: 'channel1', name: '3' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: '4' }),
+    ];
+    const subChannelCase2Page1 = [
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x6' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x5' }),
+    ];
+    const subChannelCase2Page2 = [
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x4' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x3' }),
+    ];
+    const subChannelCase2Page3 = [
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x2' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x1' }),
+    ];
+
+    const callback = jest.fn();
+    const callback2 = jest.fn();
+
+    client.http.get = jest.fn().mockImplementation((url, params) => {
+      if (params.params?.excludeDefaultMessageFeed === true) {
+        if (params?.params.options.token === 'eyJiZWZvcmUiOjU1LCJsaW1pdCI6NX0=') {
+          return Promise.resolve({
+            data: {
+              messageFeeds: subChannelCase2Page2,
+              messages: [],
+              users: [],
+              files: [],
+              paging: {
+                previous: 'eyJiZWZvcmUiOjQ1LCJsYXN0IjoxMH0=',
+                next: 'eyJiZWZvcmUiOjQ1LCJsYXN0IjoxMH0=',
+              },
+            },
+          });
+        }
+
+        if (params?.params.options.token === 'eyJiZWZvcmUiOjQ1LCJsaW1pdCI6NX0=') {
+          return Promise.resolve({
+            data: {
+              messageFeeds: subChannelCase2Page3,
+              messages: [],
+              users: [],
+              files: [],
+              paging: {
+                next: 'eyJiZWZvcmUiOjQ1LCJsYXN0IjoxMH0=',
+              },
+            },
+          });
+        }
+
+        return Promise.resolve({
+          data: {
+            messageFeeds: subChannelCase2Page1,
+            messages: [],
+            users: [],
+            files: [],
+            paging: {
+              previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+              next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            },
+          },
+        });
+      }
+      if (params?.params.options.token === 'eyJiZWZvcmUiOjU1LCJsaW1pdCI6NX0=') {
+        return Promise.resolve({
+          data: {
+            messageFeeds: subChannelCase1Page2,
+            messages: [],
+            users: [],
+            files: [],
+            paging: {
+              previous: 'eyJiZWZvcmUiOjQ1LCJsYXN0IjoxMH0=',
+              next: 'eyJiZWZvcmUiOjQ1LCJsYXN0IjoxMH0=',
+            },
+          },
+        });
+      }
+
+      return Promise.resolve({
+        data: {
+          messageFeeds: subChannelCase1Page1,
+          messages: [],
+          users: [],
+          files: [],
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      });
+    });
+
+    getSubChannels({ channelId: 'channel1' }, callback);
+    getSubChannels({ channelId: 'channel1', excludeDefaultSubChannel: true }, callback2);
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).lastCalledWith(
+      expect.objectContaining({
+        data: [convertSubChannelFromRaw(subChannelCase1Page1[0])],
+        loading: false,
+      }),
+    );
+
+    expect(callback2).toHaveBeenCalledTimes(4);
+
+    expect(callback2).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [convertSubChannelFromRaw(subChannelCase1Page1[0])],
+        loading: false,
+      }),
+    );
+
+    expect(callback2).lastCalledWith(
+      expect.objectContaining({
+        data: [convertSubChannelFromRaw(subChannelCase2Page1[0])],
+        loading: false,
+      }),
+    );
+
+    callback2.mock.lastCall[0].onNextPage();
+
+    await pause();
+
+    callback2.mock.lastCall[0].onNextPage();
+
+    await pause();
+
+    expect(callback2).toHaveBeenCalledTimes(10);
+    expect(callback2).lastCalledWith(
+      expect.objectContaining({
+        data: [convertSubChannelFromRaw(subChannelCase2Page3[0])],
+        loading: false,
+      }),
+    );
+
+    callback.mock.lastCall[0].onNextPage();
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(9);
+    expect(callback).lastCalledWith(
+      expect.objectContaining({
+        data: [convertSubChannelFromRaw(subChannelCase1Page2[0])],
+        loading: false,
+      }),
+    );
+
+    expect(callback).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [convertSubChannelFromRaw(subChannelCase2Page3[0])],
+        loading: false,
+      }),
+    );
+  });
+
+  describe('when querying the subchannel collection with specific sort and filter options, results sort correctly', () => {
+    const subChannel1 = generateRawSubChannel({ channelId: 'aaaaa' });
+    const deletedRawSubChannel = generateRawSubChannel({ channelId: 'aaaaa', isDeleted: true });
+
+    const filterCases: [
+      string,
+      Amity.SubChannelLiveCollection,
+      Amity.RawSubChannel[],
+      Amity.RawSubChannel[],
+    ][] = [
+      [
+        'includeDeleted = true',
+        { channelId: 'aaaaa', includeDeleted: true },
+        [deletedRawSubChannel, subChannel1],
+        [subChannel1],
+      ],
+      [
+        'includeDeleted = false',
+        { channelId: 'aaaaa', includeDeleted: false },
+        [deletedRawSubChannel, subChannel1],
+        [subChannel1],
+      ],
+    ];
+
+    test.each(filterCases)('%s', async (_test, params, responses, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue({
+        data: {
+          messageFeeds: responses,
+          messages: [],
+          users: [],
+          files: [],
+          paging: {},
+        },
+      });
+
+      getSubChannels(params, callback);
+
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(2);
+      expect(callback).lastCalledWith(
+        expect.objectContaining({
+          data: expected.map(convertSubChannelFromRaw),
+          loading: false,
+        }),
+      );
+    });
+  });
+
+  test('when querying two subchannel collections with the same channelId but different params, results are distinct', async () => {
+    const callback = jest.fn();
+    const callback2 = jest.fn();
+    const subChannel = generateRawSubChannel({ channelPublicId: 'channel1' });
+    const subChannel2 = generateRawSubChannel({
+      channelPublicId: 'channel1',
+      lastMessageId: 'thisissubchannelforanothercase',
+    });
+    const defaultSubChannel = generateRawSubChannel({
+      channelPublicId: 'channel1',
+      lastMessageId: 'thisisdefault',
+    });
+
+    client.http.get = jest.fn().mockImplementation((url, params) => {
+      if (params.params?.excludeDefaultMessageFeed === false) {
+        return Promise.resolve({
+          data: {
+            messageFeeds: [defaultSubChannel, subChannel],
+            messages: [],
+            users: [],
+            files: [],
+            paging: {},
+          },
+        });
+      }
+      return Promise.resolve({
+        data: {
+          messageFeeds: [subChannel2],
+          messages: [],
+          users: [],
+          files: [],
+          paging: {},
+        },
+      });
+    });
+
+    getSubChannels({ channelId: 'channel1', excludeDefaultSubChannel: false }, callback);
+    getSubChannels({ channelId: 'channel1', excludeDefaultSubChannel: true }, callback2);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await pause(100);
+
+    expect(callback.mock.calls.length).toBe(3);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [convertSubChannelFromRaw(subChannel)],
+        error: undefined,
+        loading: false,
+      }),
+    );
+    expect(callback).lastCalledWith(
+      expect.objectContaining({
+        data: [convertSubChannelFromRaw(defaultSubChannel)],
+        error: undefined,
+        loading: false,
+      }),
+    );
+
+    expect(callback2.mock.calls.length).toBe(2);
+    expect(callback2).lastCalledWith(
+      expect.objectContaining({
+        data: [convertSubChannelFromRaw(subChannel2)],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
   describe('events', () => {
     const newRawSubChannel = generateRawSubChannel({
       messageFeedId: 'sub-channel-id-2',

package/src/userRepository/api/flagUser.ts

@@ -18,7 +18,7 @@ import { fireEvent } from '~/core/events';
  * @category User API
  * @async
  * */
-export const flagUser = async (userId: Amity.User['userId']): Promise<boolean> => {
+export const flagUser = async (userId: Amity.InternalUser['userId']): Promise<boolean> => {
   const client = getActiveClient();
   client.log('user/flagUser', userId);
 

package/src/userRepository/api/getUser.ts

@@ -7,6 +7,7 @@ import { fireEvent } from '~/core/events';
 import { isInTombstone } from '~/cache/api/isInTombstone';
 import { checkIfShouldGoesToTombstone } from '~/cache/utils';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -52,7 +53,7 @@ export const getUser = async (userId: Amity.User['userId']): Promise<Amity.Cache
   fireEvent('user.fetched', data);
 
   return {
-    data: users.find(user => user.userId === userId)!,
+    data: LinkedObject.user(users.find(user => user.userId === userId)!),
     cachedAt,
   };
 };

package/src/userRepository/api/getUserByIds.ts

@@ -3,6 +3,7 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: user.get_by_ids
@@ -40,7 +41,7 @@ export const getUserByIds = async (
   fireEvent('user.fetched', data);
 
   return {
-    data: data.users,
+    data: data.users.map(user => LinkedObject.user(user)),
     cachedAt,
   };
 };
@@ -61,7 +62,7 @@ export const getUserByIds = async (
  */
 getUserByIds.locally = (
   userIds: Amity.User['userId'][],
-): Amity.Cached<Amity.User[]> | undefined => {
+): Amity.Cached<Amity.InternalUser[]> | undefined => {
   const client = getActiveClient();
   client.log('user/getUsers.locally', userIds);
 
@@ -71,7 +72,7 @@ getUserByIds.locally = (
     .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
     .filter(Boolean);
 
-  const users = cached.map(({ data }) => data);
+  const users = cached.map(({ data }) => LinkedObject.user(data));
   const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
 
   if (cached?.length < userIds.length) return;

package/src/userRepository/api/isUserFlaggedByMe.ts

@@ -16,7 +16,7 @@ import { synchronousWSCall } from '~/core/transports';
  * @category Report API
  * @async
  * */
-export const isUserFlaggedByMe = async (userId: Amity.User['userId']): Promise<boolean> => {
+export const isUserFlaggedByMe = async (userId: Amity.InternalUser['userId']): Promise<boolean> => {
   const client = getActiveClient();
   client.log('user/isUserFlaggedByMe', userId);
 

package/src/userRepository/api/queryBlockedUsers.ts

@@ -11,7 +11,7 @@ import { toPageRaw } from '~/core/query';
  * ```
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
+ * @returns A page of {@link Amity.InternalUser} objects
  *
  * @category Block API
  * @async
@@ -20,7 +20,7 @@ import { toPageRaw } from '~/core/query';
 export const queryBlockedUsers = async (
   query?: Amity.QueryBlockedUser,
 ): Promise<
-  Amity.Cached<Amity.Paged<Amity.User, Amity.PageRaw>> & {
+  Amity.Cached<Amity.Paged<Amity.InternalUser, Amity.PageRaw>> & {
     total: number;
   }
 > => {
@@ -66,18 +66,18 @@ export const queryBlockedUsers = async (
  * const { data: users } = queryBlockedUsers.locally({ page: 'page_token' })
  * ```
  *
- * Queries a paginable list of {@link Amity.User} objects from cache
+ * Queries a paginable list of {@link Amity.InternalUser} objects from cache
  * Search is performed by displayName such as `.startsWith(search)`
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
+ * @returns A page of {@link Amity.InternalUser} objects
  *
  * @category Block API
  */
 queryBlockedUsers.locally = (
   query: Parameters<typeof queryBlockedUsers>[0] = {},
 ):
-  | (Amity.Cached<Amity.Paged<Amity.User, Amity.PageRaw>> & {
+  | (Amity.Cached<Amity.Paged<Amity.InternalUser, Amity.PageRaw>> & {
       total: number;
     })
   | undefined => {
@@ -98,11 +98,13 @@ queryBlockedUsers.locally = (
   const cacheKey = ['blockedUsers', 'query', params as Amity.Serializable];
 
   const { data, cachedAt } =
-    pullFromCache<{ users: Pick<Amity.User, 'userId'>[] } & Amity.BlockedUserPaged>(cacheKey) ?? {};
+    pullFromCache<{ users: Pick<Amity.InternalUser, 'userId'>[] } & Amity.BlockedUserPaged>(
+      cacheKey,
+    ) ?? {};
 
-  const users: Amity.User[] =
+  const users: Amity.InternalUser[] =
     data?.users
-      .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
+      .map(userId => pullFromCache<Amity.InternalUser>(['user', 'get', userId])!)
       .filter(Boolean)
       .map(({ data }) => data) ?? [];
 

package/src/userRepository/api/queryUsers.ts

@@ -6,6 +6,7 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 import { fireEvent } from '~/core/events';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -13,18 +14,18 @@ import { fireEvent } from '~/core/events';
  * const { data: users, prevPage, nextPage } = await queryUsers({ displayName: 'foo' })
  * ```
  *
- * Queries a paginable list of {@link Amity.User} objects
+ * Queries a paginable list of {@link Amity.InternalUser} objects
  * Search is performed by displayName such as `.startsWith(search)`
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
+ * @returns A page of {@link Amity.InternalUser} objects
  *
  * @category User API
  * @async
  */
 export const queryUsers = async (
   query: Amity.QueryUsers = {},
-): Promise<Amity.Cached<Amity.Paged<Amity.User>>> => {
+): Promise<Amity.Cached<Amity.Paged<Amity.InternalUser>>> => {
   const client = getActiveClient();
   client.log('user/queryUsers', query);
 
@@ -70,7 +71,7 @@ export const queryUsers = async (
   const prevPage = toPage(paging.previous);
   const nextPage = toPage(paging.next);
 
-  return { data: users, cachedAt, prevPage, nextPage };
+  return { data: users.map(user => LinkedObject.user(user)), cachedAt, prevPage, nextPage };
 };
 
 /**
@@ -79,17 +80,17 @@ export const queryUsers = async (
  * const { data: users } = queryUsers.locally({ keyword: 'foo' })
  * ```
  *
- * Queries a paginable list of {@link Amity.User} objects from cache
+ * Queries a paginable list of {@link Amity.InternalUser} objects from cache
  * Search is performed by displayName such as `.startsWith(search)`
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
+ * @returns A page of {@link Amity.InternalUser} objects
  *
  * @category User API
  */
 queryUsers.locally = (
   query: Parameters<typeof queryUsers>[0] = {},
-): Amity.Cached<Amity.Paged<Amity.User>> | undefined => {
+): Amity.Cached<Amity.Paged<Amity.InternalUser>> | undefined => {
   const client = getActiveClient();
   client.log('user/queryUsers.locally', query);
 
@@ -107,11 +108,12 @@ queryUsers.locally = (
   ];
 
   const { data, cachedAt } =
-    pullFromCache<{ users: Pick<Amity.User, 'userId'>[] } & Amity.Pagination>(cacheKey) ?? {};
+    pullFromCache<{ users: Pick<Amity.InternalUser, 'userId'>[] } & Amity.Pagination>(cacheKey) ??
+    {};
 
-  const users: Amity.User[] =
+  const users: Amity.InternalUser[] =
     data?.users
-      .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
+      .map(userId => pullFromCache<Amity.InternalUser>(['user', 'get', userId])!)
       .filter(Boolean)
       .map(({ data }) => data) ?? [];
 

package/src/userRepository/api/unflagUser.ts

@@ -18,7 +18,7 @@ import { fireEvent } from '~/core/events';
  * @category User API
  * @async
  * */
-export const unflagUser = async (userId: Amity.User['userId']): Promise<boolean> => {
+export const unflagUser = async (userId: Amity.InternalUser['userId']): Promise<boolean> => {
   const client = getActiveClient();
   client.log('user/unflag', userId);
 

package/src/userRepository/api/updateUser.ts

@@ -12,22 +12,22 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * const updated = await updateUser(userId, { displayName: 'foobar' })
  * ```
  *
- * Updates an {@link Amity.User}
+ * Updates an {@link Amity.InternalUser}
  *
- * @param userId The ID of the {@link Amity.User} to update
+ * @param userId The ID of the {@link Amity.InternalUser} to update
  * @param patch The patch data to apply
- * @returns the updated {@link Amity.User} object
+ * @returns the updated {@link Amity.InternalUser} object
  *
  * @category User API
  * @async
  */
 export const updateUser = async (
-  userId: Amity.User['userId'],
+  userId: Amity.InternalUser['userId'],
   patch: Patch<
-    Amity.User,
+    Amity.InternalUser,
     'displayName' | 'description' | 'avatarFileId' | 'avatarCustomUrl' | 'metadata'
   >,
-): Promise<Amity.Cached<Amity.User>> => {
+): Promise<Amity.Cached<Amity.InternalUser>> => {
   const client = getActiveClient();
   client.log('user/updateUser', userId, patch);
 

package/src/userRepository/events/onUserDeleted.ts

@@ -8,12 +8,12 @@ import { createUserEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.User} has been deleted
+ * Fired when a {@link Amity.InternalUser} has been deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category User Events
  */
-export const onUserDeleted = (callback: Amity.Listener<Amity.User>) =>
+export const onUserDeleted = (callback: Amity.Listener<Amity.InternalUser>) =>
   createUserEventSubscriber('user.deleted', callback);

package/src/userRepository/events/onUserFetched.ts

@@ -8,12 +8,12 @@ import { createUserEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.User} has been fetched
+ * Fired when a {@link Amity.InternalUser} has been fetched
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category User Events
  */
-export const onUserFetched = (callback: Amity.Listener<Amity.User>) =>
+export const onUserFetched = (callback: Amity.Listener<Amity.InternalUser>) =>
   createUserEventSubscriber('user.fetched', callback);

package/src/userRepository/events/onUserFlagCleared.ts

@@ -8,12 +8,12 @@ import { createUserEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when flags have been cleared for a {@link Amity.User}
+ * Fired when flags have been cleared for a {@link Amity.InternalUser}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category User Events
  */
-export const onUserFlagCleared = (callback: Amity.Listener<Amity.User>) =>
+export const onUserFlagCleared = (callback: Amity.Listener<Amity.InternalUser>) =>
   createUserEventSubscriber('user.flagCleared', callback);

package/src/userRepository/events/onUserFlagged.ts

@@ -8,12 +8,12 @@ import { createUserEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.User} has been flagged
+ * Fired when a {@link Amity.InternalUser} has been flagged
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category User Events
  */
-export const onUserFlagged = (callback: Amity.Listener<Amity.User>) =>
+export const onUserFlagged = (callback: Amity.Listener<Amity.InternalUser>) =>
   createUserEventSubscriber('user.flagged', callback);