@amityco/ts-sdk 0.0.1-e26de88.0 → 0.0.1-e556efe.0

package/src/reaction/events/index.ts

@@ -1 +1,5 @@
+export * from './onReactionAdded';
 export * from './onReactionRemoved';
+
+export * from './onReactorAdded';
+export * from './onReactorRemoved';

package/src/reaction/events/onReactionAdded.ts

@@ -34,6 +34,10 @@ export const onReactionAdded = (
     }
   };
 
+  /*
+   * Important: Want to point out that reference type will never be 'message'
+   * for onReactionAdded
+   */
   if (referenceType === 'message') {
     const client = getActiveClient();
 

package/src/reaction/events/onReactorAdded.ts

@@ -0,0 +1,80 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onReactorAdded } from '@amityco/ts-sdk'
+ * const dispose = onReactorAdded('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reactor} has been added
+ *
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Events
+ * */
+export const onReactorAdded = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Reactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.Reactor,
+  ) => {
+    if (referenceType_ === referenceType && referenceId_ === referenceId) {
+      callback(reaction);
+    }
+  };
+
+  if (referenceType === 'message') {
+    const filter = (payload: Amity.MessagePayload) => {
+      if (!payload.messages[0].latestReaction) return;
+
+      const { eventName, referenceId, referenceType, userDisplayName, ...reactor } =
+        payload.messages[0].latestReaction;
+
+      if (eventName !== 'add') return;
+
+      ingestInCache(payload);
+      ingestInCache({ reactions: [reactor as Amity.Reactor] });
+
+      callbackWrapper('message', payload.messages[0].messageId, reactor);
+    };
+
+    return createEventSubscriber(client, 'reaction/onReactorAdded', 'v3.message.didUpdate', filter);
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.Reactor }) => {
+      const { reactor, ...rest } = payload;
+
+      ingestInCache(rest as Amity.PostPayload);
+      ingestInCache({ reactions: [reactor] });
+
+      callbackWrapper('post', payload.posts[0].postId, reactor);
+    };
+
+    return createEventSubscriber(client, 'post.addReaction', 'post.addReaction', filter);
+  }
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+    const { reactor, ...rest } = payload;
+
+    ingestInCache(rest as Amity.CommentPayload);
+    ingestInCache({ reactions: [reactor] });
+
+    callbackWrapper('comment', payload.comments[0].commentId, reactor);
+  };
+
+  return createEventSubscriber(client, 'comment.addReaction', 'comment.addReaction', filter);
+};

package/src/reaction/events/onReactorRemoved.ts

@@ -0,0 +1,85 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onReactorRemoved } from '@amityco/ts-sdk'
+ * const dispose = onReactorRemoved('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reactor} has been removed
+ *
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Events
+ * */
+export const onReactorRemoved = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Reactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.Reactor,
+  ) => {
+    if (referenceType_ === referenceType && referenceId_ === referenceId) {
+      callback(reaction);
+    }
+  };
+
+  if (referenceType === 'message') {
+    const filter = (payload: Amity.MessagePayload) => {
+      if (!payload.messages[0].latestReaction) return;
+
+      const { eventName, referenceId, referenceType, ...reactor } =
+        payload.messages[0].latestReaction;
+
+      if (eventName !== 'remove') return;
+
+      ingestInCache(payload);
+      ingestInCache({ reactions: [reactor as Amity.Reactor] });
+
+      callbackWrapper('message', payload.messages[0].messageId, reactor);
+    };
+
+    return createEventSubscriber(
+      client,
+      'reaction/onReactorRemoved',
+      'v3.message.didUpdate',
+      filter,
+    );
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.Reactor }) => {
+      const { reactor, ...rest } = payload;
+
+      ingestInCache(rest as Amity.PostPayload);
+      ingestInCache({ reactions: [reactor] });
+
+      callbackWrapper('post', payload.posts[0].postId, reactor);
+    };
+
+    return createEventSubscriber(client, 'post.removeReaction', 'post.removeReaction', filter);
+  }
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+    const { reactor, ...rest } = payload;
+
+    ingestInCache(rest as Amity.CommentPayload);
+    ingestInCache({ reactions: [reactor] });
+
+    callbackWrapper('comment', payload.comments[0].commentId, reactor);
+  };
+
+  return createEventSubscriber(client, 'comment.removeReaction', 'comment.removeReaction', filter);
+};

package/src/reaction/observers/index.ts

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

package/src/reaction/observers/liveReactions.ts

@@ -0,0 +1,142 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import { onReactorAdded, onReactorRemoved } from '../events';
+import { queryReactions } from '../api';
+
+/**
+ * ```js
+ * import { liveReactions } from '@amityco/ts-sdk'
+ *
+ * let reactions = []
+ * const unsub = liveReactions({
+ *   referenceId: Amity.Reaction['referenceId'],
+ *   referenceType: Amity.Reaction['referenceType'],
+ * }, response => merge(reactions, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Reaction} for a given target object
+ *
+ * @param referenceType the type of the target
+ * @param referenceId the ID of the target
+ * @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 messages
+ *
+ * @category Reactions Live Collection
+ */
+export const liveReactions = (
+  params: Amity.ReactionLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Reactor>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveReactions(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = [
+    'reaction',
+    'collection',
+    { referenceId: params.referenceId, referenceType: params.referenceType },
+  ];
+
+  const responder = (data: Amity.ReactionLiveCollectionCache) => {
+    const reactions: Amity.Reactor[] =
+      data.data
+        .map(reactorId => pullFromCache<Amity.Reactor>(['reaction', 'get', reactorId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    callback({
+      onNextPage: onFetch,
+      data: reactions,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (reaction: Amity.Reactor, action: Amity.ReactionActionType) => {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+    if (!collection) return;
+
+    if (action === 'onAdded') {
+      collection.data = [...new Set([reaction.reactionId, ...collection.data])];
+    } else if (action === 'onRemoved') {
+      collection.data = collection.data.filter(p => p !== reaction.reactionId);
+    }
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+
+    const reactions = collection?.data ?? [];
+
+    if (reactions.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryReactions, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: reactions,
+        };
+
+        if (result) {
+          data.data = [
+            ...new Set([...reactions, ...result[0].reactors.map(getResolver('reaction'))]),
+          ];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onReactorAdded(queryParams.referenceType, queryParams.referenceId, reaction =>
+      realtimeRouter(reaction, 'onAdded'),
+    ),
+    onReactorRemoved(queryParams.referenceType, queryParams.referenceId, reaction =>
+      realtimeRouter(reaction, 'onRemoved'),
+    ),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveReactions(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/reaction/utils/index.ts

@@ -1,3 +1,4 @@
 export * from './dispatchReactable';
 export * from './fetchReference';
 export * from './preparePayloadForCache';
+export * from './prepareMessagePayloadForCache';

package/src/reaction/utils/prepareMessagePayloadForCache.ts

@@ -0,0 +1,40 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+/** @hidden */
+/*
+ * @param message payload from http request without myReactions
+ * add myReactions to http response if the event was a reaction event
+ */
+export const prepareMessagePayloadForCache = (payload: Amity.Message) => {
+  const client = getActiveClient();
+
+  const cached = pullFromCache<Amity.Message>(['message', 'get', payload.messageId]);
+  // '[]' in cases where the new reaction is the first one
+  const myReactions = cached?.data.myReactions || [];
+
+  // add myReactions to the payload
+  Object.assign(payload, { myReactions });
+
+  // check if there are any updates to the reactions
+  const latestReaction = payload?.latestReaction;
+  const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
+
+  if (!isLatestReactionMine) {
+    return;
+  }
+
+  // new reaction added
+  if (latestReaction.eventName === 'add' && !myReactions.includes(latestReaction.reactionName)) {
+    Object.assign(payload, {
+      myReactions: [...myReactions, latestReaction.reactionName],
+    });
+  }
+
+  // existing reaction removed
+  if (latestReaction.eventName === 'remove' && myReactions.includes(latestReaction.reactionName)) {
+    Object.assign(payload, {
+      myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
+    });
+  }
+};

package/src/report/api/createReport.ts

@@ -29,7 +29,13 @@ export const createReport = async (
 
   const { data } = await client.http.post<
     Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(`/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`);
+  >(
+    `/api/${
+      referenceType === 'user'
+        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
+        : `v3/${domainName}/${encodeURIComponent(referenceId)}/flag`
+    }`,
+  );
 
   if (client.cache) ingestInCache(data);
 

package/src/report/api/deleteReport.ts

@@ -29,7 +29,13 @@ export const deleteReport = async (
 
   const { data } = await client.http.delete<
     Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(`/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`);
+  >(
+    `/api/${
+      referenceType === 'user'
+        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
+        : `v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`
+    }`,
+  );
 
   if (client.cache) ingestInCache(data);
 

package/src/user/api/updateUser.ts

@@ -19,7 +19,10 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const updateUser = async (
   userId: Amity.User['userId'],
-  patch: Patch<Amity.User, 'displayName' | 'description' | 'avatarFileId' | 'metadata'>,
+  patch: Patch<
+    Amity.User,
+    'displayName' | 'description' | 'avatarFileId' | 'avatarCustomUrl' | 'metadata'
+  >,
 ): Promise<Amity.Cached<Amity.User>> => {
   const client = getActiveClient();
   client.log('user/updateUser', userId, patch);

package/src/user/events/index.ts

@@ -1,4 +1,5 @@
 export * from './onUserUpdated';
+export * from './onUserDeleted';
 
 export * from './onUserFlagged';
 export * from './onUserUnflagged';

package/src/user/events/onUserDeleted.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserDeleted } from '@amityco/ts-sdk'
+ * const dispose = onUserDeleted(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} 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>) =>
+  createUserEventSubscriber('user.deleted', callback);

package/src/user/events/utils.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';

package/src/user/observers/observeUser.ts

@@ -3,7 +3,13 @@ import { createQuery, runQuery } from '~/core/query/query';
 import { getActiveClient } from '~/client/api';
 
 import { getUser } from '../api';
-import { onUserUpdated, onUserFlagged, onUserUnflagged, onUserFlagCleared } from '../events';
+import {
+  onUserUpdated,
+  onUserDeleted,
+  onUserFlagged,
+  onUserUnflagged,
+  onUserFlagCleared,
+} from '../events';
 
 /**
  * ```js
@@ -21,7 +27,7 @@ import { onUserUpdated, onUserFlagged, onUserUnflagged, onUserFlagCleared } from
  * @category User Observer
  */
 export const observeUser = <
-  Events extends ['onFetch', 'onUpdate', 'onFlagged', 'onUnflagged', 'onFlagCleared'],
+  Events extends ['onFetch', 'onUpdate', 'onDelete', 'onFlagged', 'onUnflagged', 'onFlagCleared'],
 >(
   userId: string,
   callback: Amity.ObjectListener<Amity.Snapshot<Amity.User>, Events>,
@@ -47,6 +53,7 @@ export const observeUser = <
 
   disposers.push(
     onUserUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onUserDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
     onUserFlagged(data => router({ data, loading: false, origin: 'event' }, 'onFlagged')),
     onUserUnflagged(data => router({ data, loading: false, origin: 'event' }, 'onUnflagged')),
     onUserFlagCleared(data => router({ data, loading: false, origin: 'event' }, 'onFlagCleared')),

package/src/utils/constants.ts

@@ -0,0 +1,2 @@
+export const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+export const COLLECTION_DEFAULT_CACHING_POLICY: Amity.QueryPolicy = 'cache_then_server';

package/src/utils/env.ts

@@ -1,5 +1,7 @@
 /* eslint-disable no-undef */
-const theGlobal = globalThis || global || window;
+const theGlobal =
+  // eslint-disable-next-line no-nested-ternary
+  typeof globalThis === 'object' ? globalThis : typeof global === 'object' ? global : window;
 
 export const { process: safeProcess = {} }: { process: Partial<NodeJS.Process> } = theGlobal;
 

package/src/utils/tests/client.ts

@@ -0,0 +1,5 @@
+import { createClient } from '~/client/api';
+
+const client = createClient('key', 'sg');
+
+export default client;

package/src/utils/tests/dummy.ts

@@ -0,0 +1,7 @@
+export const userPosts = {
+  targetId: 'userId',
+  targetType: 'user' as Amity.PostTargetType,
+  page1: ['postId11', 'postId12', 'postId13'],
+  page2: ['postId21', 'postId22', 'postId23'],
+  page3: ['postId31', 'postId32', 'postId33'],
+};

package/src/utils/tests/index.ts

@@ -0,0 +1,2 @@
+export { userPosts } from './dummy';
+export { default as client } from './client';

package/tsconfig.json

@@ -1,29 +1,30 @@
 {
-  "extends": "../../tsconfig.json",
+	"extends": "../../tsconfig.json",
 
-  "include": ["./src"],
-  "exclude": ["node_modules"],
+	"include": ["./src"],
+	"exclude": ["node_modules", "**/*.spec.ts"],
 
-  "compilerOptions": {
-    "baseUrl": "./src",
-    "paths": {
-      "~/*": ["./*"],
-    },
+	"compilerOptions": {
+		"baseUrl": "./src",
+		"paths": {
+			"~/*": ["./*"]
+		},
 
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "declaration": true,
-    "declarationDir": "./dist",
-    "noEmit": true, // by rollup
+		"rootDir": "./src",
+		"outDir": "./dist",
+		"declaration": true,
+		"declarationDir": "./dist",
+		"noEmit": true,
 
-    "module": "es2020",
-    "target": "es2017",
+		"module": "es2020",
+		"target": "es2017",
 
-    "lib": [
-      "esnext",
-      "es7",
-      "es6",
-      "dom",
-    ],
-  }
+		"lib": [
+			"esnext",
+			"es7",
+			"es6",
+			"dom"
+		],
+		"resolveJsonModule": true
+	}
 }

package/dist/channel/events/onMemberAdded.d.ts

@@ -1,17 +0,0 @@
-/**
- * ```js
- * import { onMemberAdded } from '@amityco/ts-sdk'
- * const dispose = onMemberAdded(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-export declare const onMemberAdded: (callback: Amity.Listener<Amity.Channel>) => Amity.Unsubscriber;
-//# sourceMappingURL=onMemberAdded.d.ts.map

package/dist/channel/events/onMemberAdded.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"onMemberAdded.d.ts","sourceRoot":"","sources":["../../../src/channel/events/onMemberAdded.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,aAAc,MAAM,QAAQ,CAAC,MAAM,OAAO,CAAC,uBASpE,CAAC"}

package/dist/channel/events/onMemberRemoved.d.ts

@@ -1,17 +0,0 @@
-/**
- * ```js
- * import { onMemberRemoved } from '@amityco/ts-sdk'
- * const dispose = onMemberRemoved(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.User} has been removed from any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-export declare const onMemberRemoved: (callback: Amity.Listener<Amity.Channel>) => Amity.Unsubscriber;
-//# sourceMappingURL=onMemberRemoved.d.ts.map

package/dist/channel/events/onMemberRemoved.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"onMemberRemoved.d.ts","sourceRoot":"","sources":["../../../src/channel/events/onMemberRemoved.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,aAAc,MAAM,QAAQ,CAAC,MAAM,OAAO,CAAC,uBAStE,CAAC"}

package/dist/community/api/addCommunityMembersRole.d.ts

@@ -1,18 +0,0 @@
-/**
- * ```js
- * import { addCommunityMembersRole } from '@amityco/ts-sdk'
- * const updated = await addCommunityMembersRole(communityId, 'foo', ['bar'])
- * ```
- *
- * Adds an {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Community}
- *
- * @param communityId The ID of the {@link Amity.Community} to perform
- * @param roleId The ID of the {@link Amity.Role} to apply
- * @param userId Array of IDs of the {@link Amity.User} to perform
- * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.User} in the {@link Amity.Community}
- *
- * @category Community API
- * @async
- */
-export declare const addCommunityMembersRole: (communityId: Amity.Community['communityId'], roleId: Amity.Role['roleId'], userIds: Amity.User['userId'][]) => Promise<boolean>;
-//# sourceMappingURL=addCommunityMembersRole.d.ts.map

package/dist/community/api/addCommunityMembersRole.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"addCommunityMembersRole.d.ts","sourceRoot":"","sources":["../../../src/community/api/addCommunityMembersRole.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,uBAAuB,gBACrB,MAAM,SAAS,CAAC,aAAa,CAAC,UACnC,MAAM,IAAI,CAAC,QAAQ,CAAC,WACnB,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,KAC9B,QAAQ,OAAO,CAgBjB,CAAC"}

package/dist/community/api/removeCommunityMembersRole.d.ts

@@ -1,18 +0,0 @@
-/**
- * ```js
- * import { removeCommunityMembersRole } from '@amityco/ts-sdk'
- * const updated = await removeCommunityMembersRole(communityId,  'foo', ['bar'])
- * ```
- *
- * Removes an {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Community}
- *
- * @param communityId The ID of the {@link Amity.Community} to perform
- * @param role The ID of the {@link Amity.Role} to apply
- * @param userId Array of IDs of the {@link Amity.User} to perform
- * @returns A success boolean if the {@link Amity.Role} were removed from list of {@link Amity.User} in the {@link Amity.Community}
- *
- * @category Community API
- * @async
- */
-export declare const removeCommunityMembersRole: (communityId: Amity.Community['communityId'], roleId: Amity.Role['roleId'], userIds: Amity.User['userId'][]) => Promise<boolean>;
-//# sourceMappingURL=removeCommunityMembersRole.d.ts.map

package/dist/community/api/removeCommunityMembersRole.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"removeCommunityMembersRole.d.ts","sourceRoot":"","sources":["../../../src/community/api/removeCommunityMembersRole.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B,gBACxB,MAAM,SAAS,CAAC,aAAa,CAAC,UACnC,MAAM,IAAI,CAAC,QAAQ,CAAC,WACnB,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,KAC9B,QAAQ,OAAO,CAgBjB,CAAC"}