@amityco/ts-sdk 0.0.1-beta.2 → 0.0.1-c58e50d.0

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

@@ -0,0 +1,17 @@
+/**
+ * ```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/observers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './observeChannel';
+//# sourceMappingURL=index.d.ts.map

package/dist/channel/observers/observeChannel.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ```js
+ * import { observeChannel } from '@amityco/ts-sdk'
+ *
+ * let channel = {}
+ * const dispose = observeChannel(channelId, ({ data }) => channel = data)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Channel}
+ *
+ * @param channelId the ID of the channel 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 channel
+ *
+ * @category Channel Observer
+ */
+export declare const observeChannel: <Events extends ["onFetch", "onUpdate", "onDelete", "onJoin", "onLeft", "onMemberAdded", "onMemberRemoved"]>(channelId: string, callback: Amity.ObjectListener<{
+    data?: Amity.Channel<any> | undefined;
+} & Amity.QueryMetadata, Events>) => Amity.Unsubscriber;
+//# sourceMappingURL=observeChannel.d.ts.map

package/dist/client/api/activeClient.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Get the active client
+ *
+ * @returns the active client instance
+ *
+ * @hidden
+ */
+export declare const getActiveClient: () => Amity.Client;
+/**
+ * Sets the active client
+ *
+ * @param client the client to assume as currently active client
+ *
+ * @hidden
+ */
+export declare const setActiveClient: (client: Amity.Client) => void;
+//# sourceMappingURL=activeClient.d.ts.map

package/dist/client/api/clearCache.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ```js
+ * import { clearCache } from '@amityco/ts-sdk'
+ * clearCache()
+ * ```
+ *
+ * Resets the state of the given {@link Amity.Store} names within
+ * the {@link Amity.Cache} object of a {@link Amity.Client} instance
+ *
+ * @param stores an array of the stores names to be wiped
+ *
+ * @category Client API
+ */
+export declare const clearCache: (stores?: Amity.Domain[]) => void;
+//# sourceMappingURL=clearCache.d.ts.map

package/dist/client/api/clearCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearCache.d.ts","sourceRoot":"","sources":["../../../src/client/api/clearCache.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,YACb,MAAM,MAAM,EAAE,SAMvB,CAAA"}

package/dist/client/api/connectClient.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ```js
+ * import { connectClient } from '@amityco/ts-sdk/client/api'
+ * const success = await connectClient({
+ *   userId: 'XYZ123456789',
+ * })
+ * ```
+ *
+ * Connects an {@link Amity.Client} instance to ASC servers
+ *
+ * @param userId the user ID for the current session
+ * @param displayName the user's displayName for the current session
+ * @param deviceId Manual override of the user's device id (for device management)
+ * @param authToken The authentication token - necessary when network option is set to secure
+ * @returns a success boolean if connected
+ *
+ * @category Client API
+ * @async
+ */
+export declare const connectClient: (params: {
+    userId: Amity.User['userId'];
+    displayName?: Amity.User['displayName'];
+    authToken?: string;
+    deviceId?: Amity.Device['deviceId'];
+}) => Promise<boolean>;
+//# sourceMappingURL=connectClient.d.ts.map

package/dist/client/api/connectClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectClient.d.ts","sourceRoot":"","sources":["../../../src/client/api/connectClient.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,WAAkB;IAC1C,MAAM,EAAE,MAAM,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC,aAAa,CAAC,CAAC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,MAAM,CAAC,UAAU,CAAC,CAAC;CACrC,KAAG,QAAQ,OAAO,CA+BlB,CAAA"}

package/dist/client/api/createClient.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ```js
+ * import { createClient } from '@amityco/ts-sdk'
+ * const client = createClient(apiKey, 'https://asc.server/', 'myClient')
+ * ```
+ *
+ * Creates a new {@link Amity.Client} instance
+ *
+ * @param apiKey for the {@link Amity.Client} instance
+ * @param apiEndpoint endpoint to connect to
+ * @param debugSession session's identifier for the client's logger instance
+ * @returns A {@link Amity.Client} instance
+ *
+ * @category Client API
+ **/
+export declare const createClient: (apiKey: string, apiEndpoint?: string, debugSession?: string) => Amity.Client;
+//# sourceMappingURL=createClient.d.ts.map

package/dist/client/api/disconnectClient.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ```js
+ * import { disconnectClient } from '@amityco/ts-sdk'
+ * const success = await disconnectClient()
+ * ```
+ *
+ * Disconnects an {@link Amity.Client} instance from ASC servers
+ *
+ * @param client The {@link Amity.Client} instance to disconnect
+ * @returns a success boolean if disconnected
+ *
+ * @category Client API
+ * @async
+ */
+export declare const disconnectClient: () => Promise<boolean>;
+//# sourceMappingURL=disconnectClient.d.ts.map

package/dist/client/api/enableCache.d.ts

@@ -0,0 +1,15 @@
+import { createCache } from '~/core/cache';
+/**
+ * ```js
+ * import { enableCache } from '@amityco/ts-sdk'
+ * enableCache()
+ * ```
+ *
+ * Adds a new {@link Amity.Cache} object to an {@link Amity.Client} instance
+ *
+ * @param stores a partial dictionary of stores to be used for caching
+ *
+ * @category Client API
+ */
+export declare const enableCache: (stores?: Parameters<typeof createCache>[0]) => void;
+//# sourceMappingURL=enableCache.d.ts.map

package/dist/client/api/enableCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enableCache.d.ts","sourceRoot":"","sources":["../../../src/client/api/enableCache.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAG1C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,YACd,WAAW,kBAAkB,CAAC,CAAC,CAAC,CAAC,SAgB1C,CAAA"}

package/dist/client/api/getToken.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Retrieves a pair of {@link Amity.Tokens} necessary for connection
+ *
+ * @param userId The userId to use to issue a token
+ * @param displayName The user's displayName
+ * @param deviceId The user's device Id (can be manually set for native users)
+ * @param authToken The authentication token - necessary when network option is set to secure
+ * @return The accessToken for the given userId
+ *
+ * @category Client API
+ * @hidden
+ */
+export declare const getToken: (params: {
+    userId: Amity.User['userId'];
+    displayName: Amity.User['displayName'];
+    authToken?: string;
+    deviceId: Amity.Device['deviceId'];
+}) => Promise<Amity.Tokens>;
+//# sourceMappingURL=getToken.d.ts.map

package/dist/client/api/index.d.ts

@@ -0,0 +1,8 @@
+export { getActiveClient } from './activeClient';
+export * from './createClient';
+export * from './connectClient';
+export * from './disconnectClient';
+export * from './isConnected';
+export * from './enableCache';
+export * from './clearCache';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,cAAc,CAAA"}

package/dist/client/api/isConnected.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ```js
+ * import { isConnected } from '@amityco/ts-sdk'
+ * const connected = isConnected()
+ * ```
+ *
+ * Checks if a {@link Amity.Client} instance is connected to ASC servers
+ *
+ * @returns a success boolean if connected
+ *
+ * @category Client API
+ */
+export declare const isConnected: () => boolean;
+//# sourceMappingURL=isConnected.d.ts.map

package/dist/client/events/index.d.ts

@@ -0,0 +1,2 @@
+export * from './onClientDisconnected';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/events/onClientDisconnected.d.ts

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

package/dist/comment/api/createComment.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ```js
+ * import { createComment } from '@amityco/ts-sdk'
+ * const newComment = await createComment(bundle)
+ * ```
+ *
+ * Creates an {@link Amity.Comment}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Comment}
+ * @returns The newly created {@link Amity.Comment}
+ *
+ * @category Comment API
+ * @async
+ */
+export declare const createComment: <T extends "text">(bundle: Pick<Amity.Comment<T>, "referenceType" | "referenceId" | "parentId" | "data" | "metadata">) => Promise<Amity.Comment<any>>;
+//# sourceMappingURL=createComment.d.ts.map

package/dist/comment/api/createComment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createComment.d.ts","sourceRoot":"","sources":["../../../src/comment/api/createComment.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,uJAoBzB,CAAA"}

package/dist/comment/api/deleteComment.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ```js
+ * import { deleteComment } from '@amityco/ts-sdk'
+ * const success = await deleteComment('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Comment}
+ *
+ * @param commentId The {@link Amity.Comment} ID to delete
+ * @return A success boolean if the {@link Amity.Comment} was deleted
+ *
+ * @category Comment API
+ * @async
+ */
+export declare const deleteComment: (commentId: Amity.Comment['commentId']) => Promise<Amity.Comment<any>>;
+//# sourceMappingURL=deleteComment.d.ts.map

package/dist/comment/api/getComment.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ```js
+ * import { getComment } from '@amityco/ts-sdk'
+ * const comment = await getComment('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Comment} object
+ *
+ * @param commentId the ID of the {@link Amity.Comment} to fetch
+ * @returns the associated {@link Amity.Comment} object
+ *
+ * @category Comment API
+ * @async
+ */
+export declare const getComment: {
+    (commentId: Amity.Comment['commentId']): Promise<Amity.Comment<any>>;
+    /**
+     * ```js
+     * import { getComment } from '@amityco/ts-sdk'
+     * const comment = getComment.locally('foobar')
+     * ```
+     *
+     * Fetches a {@link Amity.Comment} object
+     *
+     * @param commentId the ID of the {@link Amity.Comment} to fetch
+     * @returns the associated {@link Amity.Comment} object
+     *
+     * @category Comment API
+     */
+    locally(commentId: Amity.Comment['commentId']): Amity.Comment<any>;
+};
+//# sourceMappingURL=getComment.d.ts.map

package/dist/comment/api/getComments.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ```js
+ * import { getComments } from '@amityco/ts-sdk'
+ * const comments = await getComments(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Comment} objects
+ *
+ * @param commentIds the IDs of the {@link Amity.Comment} to fetch
+ * @returns the associated collection of {@link Amity.Comment} objects
+ *
+ * @category Comment API
+ * @async
+ */
+export declare const getComments: {
+    (commentIds: Amity.Comment['commentId'][]): Promise<Record<string, Amity.Comment<any>>>;
+    /**
+     * ```js
+     * import { getComments } from '@amityco/ts-sdk'
+     * const comments = getComments.locally(['foo', 'bar'])
+     * ```
+     *
+     * Fetches a collection of {@link Amity.Comment} objects from cache
+     *
+     * @param commentIds the IDs of the {@link Amity.Comment} to fetch
+     * @returns the associated collection of {@link Amity.Comment} objects
+     *
+     * @category Comment API
+     */
+    locally(commentIds: Amity.Comment['commentId'][]): Record<string, Amity.Comment<any>> | undefined;
+};
+//# sourceMappingURL=getComments.d.ts.map

package/dist/comment/api/index.d.ts

@@ -0,0 +1,7 @@
+export * from './queryComments';
+export * from './getComments';
+export * from './getComment';
+export * from './createComment';
+export * from './updateComment';
+export * from './deleteComment';
+//# sourceMappingURL=index.d.ts.map

package/dist/comment/api/queryComments.d.ts

@@ -0,0 +1,53 @@
+/**
+ * ```js
+ * import { queryComments } from '@amityco/ts-sdk'
+ * const comments = await queryComments({ postId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Comment} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Comment} objects
+ *
+ * @category Comment API
+ * @async
+ */
+export declare const queryComments: {
+    (query: {
+        referenceType: Amity.Comment['referenceType'];
+        referenceId: Amity.Comment['referenceId'];
+        parentId?: Amity.Comment['commentId'] | null;
+        hasFlag?: boolean;
+        isDeleted?: Amity.Comment['isDeleted'];
+        page?: Amity.Page;
+    }): Promise<{
+        data: Record<string, Amity.Comment<any>>;
+        prevPage: Amity.Page | null;
+        nextPage: Amity.Page | null;
+    }>;
+    /**
+     * ```js
+     * import { queryComments } from '@amityco/ts-sdk'
+     * const comments = queryComments.locally({ postId })
+     * ```
+     *
+     * Queries a paginable list of {@link Amity.Comment} objects from cache
+     *
+     * @param query The query parameters
+     * @returns comments
+     *
+     * @category Comment API
+     */
+    locally(query: Parameters<typeof queryComments>[0]): {
+        data: Record<string, Amity.Comment<any>>;
+        nextPage: {
+            after: number;
+            limit: number;
+        };
+        prevPage: {
+            before: number;
+            limit: number;
+        } | undefined;
+    } | undefined;
+};
+//# sourceMappingURL=queryComments.d.ts.map

package/dist/comment/api/queryComments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryComments.d.ts","sourceRoot":"","sources":["../../../src/comment/api/queryComments.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa;YAAiB;QACzC,aAAa,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;QAC9C,WAAW,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;QAC1C,QAAQ,CAAC,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,IAAI,CAAA;QAC5C,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,SAAS,CAAC,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;QACtC,IAAI,CAAC,EAAE,MAAM,IAAI,CAAA;KAClB;;;;;IAmCD;;;;;;;;;;;;OAYG;mBAEM,WAAW,oBAAoB,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;CAhB3C,CAAA"}

package/dist/comment/api/updateComment.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ```js
+ * import { updateComment } from '@amityco/ts-sdk'
+ * const updated = await updateComment(commentId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Comment}
+ *
+ * @param commentId The ID of the {@link Amity.Comment} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Comment} object
+ *
+ * @category Comment API
+ * @async
+ */
+export declare const updateComment: (commentId: Amity.Comment['commentId'], patch: Patch<Amity.Comment, 'data' | 'metadata'>) => Promise<Amity.Comment<any>>;
+//# sourceMappingURL=updateComment.d.ts.map

package/dist/comment/events/index.d.ts

@@ -0,0 +1,4 @@
+export * from './onCommentCreated';
+export * from './onCommentUpdated';
+export * from './onCommentDeleted';
+//# sourceMappingURL=index.d.ts.map

package/dist/comment/events/onCommentCreated.d.ts

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

package/dist/comment/events/onCommentDeleted.d.ts

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

package/dist/comment/events/onCommentUpdated.d.ts

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

package/dist/comment/observers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './observeComments';
+export * from './observeComment';
+//# sourceMappingURL=index.d.ts.map

package/dist/comment/observers/observeComment.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ```js
+ * import { observeComment } from '@amityco/ts-sdk'
+ *
+ * let comment = {}
+ * const dispose = observeComment(commentId, ({ data }) => comment = data)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Comment}
+ *
+ * @param commentId the ID of the comment 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 comment
+ *
+ * @category Comment Observer
+ */
+export declare const observeComment: <Events extends ["onFetch", "onUpdate", "onDelete"]>(commentId: string, callback: Amity.ObjectListener<{
+    data?: Amity.Comment<any> | undefined;
+} & Amity.QueryMetadata, Events>, policy?: Amity.QueryPolicy) => Amity.Unsubscriber;
+//# sourceMappingURL=observeComment.d.ts.map

package/dist/comment/observers/observeComments.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ```js
+ * import { observeComments } from '@amityco/ts-sdk'
+ *
+ * let comments = []
+ * const unsub = observeComments(postId, comment => merge(comments, comment))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Comment} for a given {@link Amity.Post} object
+ *
+ * @param postId the ID of the post where to observe the comments
+ * @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 comments
+ *
+ * @category Comment Observer
+ */
+export declare const observeComments: (postId: Amity.Post['postId'], callback: Amity.ObjectListener<Amity.Comment, [
+    'onCreate',
+    'onUpdate',
+    'onDelete'
+]>) => Amity.Unsubscriber;
+//# sourceMappingURL=observeComments.d.ts.map

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"addCommunityMembers.d.ts","sourceRoot":"","sources":["../../../src/community/api/addCommunityMembers.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,gBACjB,MAAM,SAAS,CAAC,aAAa,CAAC,WAClC,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,qBAsBhC,CAAA"}

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

@@ -0,0 +1,18 @@
+/**
+ * ```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