@alfresco/js-api 7.3.0-1529 → 7.3.0

package/esm2020/api/content-rest-api/api/groups.api.mjs

@@ -0,0 +1,308 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GroupMemberPaging, GroupPaging } from '../model';
+import { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+/**
+ * Groups service.
+ */
+export class GroupsApi extends BaseApi {
+    /**
+     * Create a group
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.
+     *
+     * Create a group.
+     *
+     * The group id must start with \"GROUP\\_\". If this is omitted it will be added automatically.
+     * This format is also returned when listing groups or group memberships. It should be noted
+     * that the other group-related operations also expect the id to start with \"GROUP\\_\".
+     *
+     * If one or more parentIds are specified then the group will be created and become a member of each of the specified parent groups.
+     * If no parentIds are specified then the group will be created as a root group.
+     * The group will be created in the **APP.DEFAULT** and **AUTH.ALF** zones.
+     *
+     * You must have admin rights to create a group.
+     *
+     * @param groupBodyCreate The group to create.
+     * @param opts Optional parameters
+     * @returns Promise<GroupEntry>
+     */
+    createGroup(groupBodyCreate, opts) {
+        throwIfNotDefined(groupBodyCreate, 'groupBodyCreate');
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/groups',
+            queryParams,
+            bodyParam: groupBodyCreate
+        });
+    }
+    /**
+     * Create a group membership
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.
+     *
+     * Create a group membership (for an existing person or group) within a group **groupId**.
+     * If the added group was previously a root group then it becomes a non-root group since it now has a parent.
+     * It is an error to specify an **id** that does not exist.
+     * You must have admin rights to create a group membership.
+     *
+     * @param groupId The identifier of a group.
+     * @param groupMembershipBodyCreate The group membership to add (person or sub-group).
+     * @param opts Optional parameters
+     * @returns Promise<GroupMemberEntry>
+     */
+    createGroupMembership(groupId, groupMembershipBodyCreate, opts) {
+        throwIfNotDefined(groupId, 'groupId');
+        throwIfNotDefined(groupMembershipBodyCreate, 'groupMembershipBodyCreate');
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/groups/{groupId}/members',
+            pathParams: { groupId },
+            queryParams,
+            bodyParam: groupMembershipBodyCreate
+        });
+    }
+    /**
+     * Delete a group
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.
+     *
+     * Delete group **groupId**.
+     * The option to cascade delete applies this recursively to any hierarchy of group members.
+     * In this case, removing a group member does not delete the person or sub-group itself.
+     * If a removed sub-group no longer has any parent groups then it becomes a root group.
+     * You must have admin rights to delete a group.
+     *
+     * @param groupId The identifier of a group.
+     * @param opts Optional parameters
+     * @returns Promise
+     */
+    deleteGroup(groupId, opts) {
+        throwIfNotDefined(groupId, 'groupId');
+        opts = opts || {};
+        const cascadeDelete = opts['cascade'] ? opts['cascade'] : false;
+        const pathParams = {
+            groupId
+        };
+        const queryParams = {
+            cascade: cascadeDelete
+        };
+        return this.delete({
+            path: '/groups/{groupId}',
+            pathParams,
+            queryParams
+        });
+    }
+    /**
+     * Delete a group membership
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.
+     *
+     * Delete group member **groupMemberId** (person or sub-group) from group **groupId**.
+     * Removing a group member does not delete the person or sub-group itself.\
+     * If a removed sub-group no longer has any parent groups then it becomes a root group.
+     *
+     * @param groupId The identifier of a group.
+     * @param groupMemberId The identifier of a person or group.
+     * @returns Promise<{}>
+     */
+    deleteGroupMembership(groupId, groupMemberId) {
+        throwIfNotDefined(groupId, 'groupId');
+        throwIfNotDefined(groupMemberId, 'groupMemberId');
+        const pathParams = {
+            groupId,
+            groupMemberId
+        };
+        return this.delete({
+            path: '/groups/{groupId}/members/{groupMemberId}',
+            pathParams
+        });
+    }
+    /**
+     * Get group details
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.
+     *
+     * Get details for group **groupId**.
+     * You can use the **include** parameter to return additional information.
+     *
+     * @param groupId The identifier of a group.
+     * @param opts Optional parameters
+     * @returns Promise<GroupEntry>
+     */
+    getGroup(groupId, opts) {
+        throwIfNotDefined(groupId, 'groupId');
+        const pathParams = {
+            groupId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/groups/{groupId}',
+            pathParams,
+            queryParams
+        });
+    }
+    /**
+     * List memberships of a group
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.
+     *
+     * Gets a list of the group memberships for the group **groupId**.
+     *
+     * You can use the **where** parameter to filter the returned groups by **memberType**.
+     * Example to filter by **memberType**, use any one of:
+     * - (memberType='GROUP')
+     * - (memberType='PERSON')
+     *
+     * The default sort order for the returned list is for group members to be sorted by ascending displayName.
+     * You can override the default by using the **orderBy** parameter. You can specify one of the following fields in the **orderBy** parameter:
+     * - id
+     * - displayName
+     *
+     * @param groupId The identifier of a group.
+     * @param opts Optional parameters
+     * @returns Promise<GroupMemberPaging>
+     */
+    listGroupMemberships(groupId, opts) {
+        throwIfNotDefined(groupId, 'groupId');
+        const pathParams = {
+            groupId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),
+            where: opts?.where,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/groups/{groupId}/members',
+            pathParams,
+            queryParams,
+            returnType: GroupMemberPaging
+        });
+    }
+    /**
+     * List group memberships
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.
+     *
+     * @param personId The identifier of a person.
+     * @param opts Optional parameters
+     * @param opts.skipCount The number of entities that exist in the collection before those included in this list.
+     * If not supplied then the default value is 0. (default to 0)
+     * @param opts.maxItems The maximum number of items to return in the list. If not supplied then the default value is 100. (default to 100)
+     * @param opts.orderBy A string to control the order of the entities returned in a list. You can use the **orderBy** parameter to
+     * sort the list by one or more fields.
+     * Each field has a default sort order, which is normally ascending order. Read the API method implementation notes
+     * above to check if any fields used in this method have a descending default search order.
+     * To sort the entities in a specific order, you can use the **ASC** and **DESC** keywords for any field.
+     * @param opts.include Returns additional information about the group. The following optional fields can be requested:
+     * - parentIds
+     * - zones
+     * @param opts.where A string to restrict the returned objects by using a predicate.
+     * @param opts.fields A list of field names.
+     * You can use this parameter to restrict the fields
+     * returned within a response if, for example, you want to save on overall bandwidth.
+     * The list applies to a returned individual entity or entries within a collection.
+     * If the API method also supports the **include** parameter, then the fields specified in the **include**
+     * parameter are returned in addition to those specified in the **fields** parameter.
+     * @returns Promise<GroupPaging>
+     */
+    listGroupMembershipsForPerson(personId, opts) {
+        throwIfNotDefined(personId, 'personId');
+        const pathParams = {
+            personId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),
+            include: buildCollectionParam(opts?.include, 'csv'),
+            where: opts?.where,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/people/{personId}/groups',
+            pathParams,
+            queryParams,
+            returnType: GroupPaging
+        });
+    }
+    /**
+     * List groups
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.
+     *
+     * @param opts Optional parameters
+     * @returns Promise<GroupPaging>
+     */
+    listGroups(opts) {
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),
+            include: buildCollectionParam(opts?.include, 'csv'),
+            where: opts?.where,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/groups',
+            queryParams,
+            returnType: GroupPaging
+        });
+    }
+    /**
+     * Update group details
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.
+     * You must have admin rights to update a group.
+     *
+     * @param groupId The identifier of a group.
+     * @param groupBodyUpdate The group information to update.
+     * @param opts Optional parameters
+     * @returns Promise<GroupEntry>
+     */
+    updateGroup(groupId, groupBodyUpdate, opts) {
+        throwIfNotDefined(groupId, 'groupId');
+        throwIfNotDefined(groupBodyUpdate, 'groupBodyUpdate');
+        const pathParams = {
+            groupId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/groups/{groupId}',
+            pathParams,
+            queryParams,
+            bodyParam: groupBodyUpdate
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"groups.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/content-rest-api/api/groups.api.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { GroupBodyCreate, GroupBodyUpdate, GroupEntry, GroupMemberEntry, GroupMemberPaging, GroupMembershipBodyCreate, GroupPaging } from '../model';\nimport { BaseApi } from './base.api';\nimport { throwIfNotDefined } from '../../../assert';\nimport { buildCollectionParam } from '../../../alfrescoApiClient';\nimport { ContentFieldsQuery, ContentIncludeQuery, ContentPagingQuery } from './types';\n\nexport interface ListGroupMembershipsOpts {\n    /**\n     * A string to control the order of the entities returned in a list. You can use the **orderBy** parameter to\n     * sort the list by one or more fields.\n     *\n     * Each field has a default sort order, which is normally ascending order. Read the API method implementation notes\n     * above to check if any fields used in this method have a descending default search order.\n     *\n     * To sort the entities in a specific order, you can use the **ASC** and **DESC** keywords for any field\n     */\n    orderBy?: string[];\n    // A string to restrict the returned objects by using a predicate.\n    where?: string;\n}\n\nexport interface GroupPagingOpts {\n    /**\n     * A string to control the order of the entities returned in a list. You can use the **orderBy** parameter to\n     * sort the list by one or more fields.\n     *\n     * Each field has a default sort order, which is normally ascending order. Read the API method implementation notes\n     * above to check if any fields used in this method have a descending default search order.\n     *\n     * To sort the entities in a specific order, you can use the **ASC** and **DESC** keywords for any field.\n     */\n    orderBy?: string[];\n    /**\n     * A string to restrict the returned objects by using a predicate.\n     */\n    where?: string;\n}\n\nexport type DeleteGroupOpts = { cascade?: boolean };\n\n/**\n * Groups service.\n */\nexport class GroupsApi extends BaseApi {\n    /**\n     * Create a group\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.\n     *\n     * Create a group.\n     *\n     * The group id must start with \\\"GROUP\\\\_\\\". If this is omitted it will be added automatically.\n     * This format is also returned when listing groups or group memberships. It should be noted\n     * that the other group-related operations also expect the id to start with \\\"GROUP\\\\_\\\".\n     *\n     * If one or more parentIds are specified then the group will be created and become a member of each of the specified parent groups.\n     * If no parentIds are specified then the group will be created as a root group.\n     * The group will be created in the **APP.DEFAULT** and **AUTH.ALF** zones.\n     *\n     * You must have admin rights to create a group.\n     *\n     * @param groupBodyCreate The group to create.\n     * @param opts Optional parameters\n     * @returns Promise<GroupEntry>\n     */\n    createGroup(groupBodyCreate: GroupBodyCreate, opts?: ContentIncludeQuery & ContentFieldsQuery): Promise<GroupEntry> {\n        throwIfNotDefined(groupBodyCreate, 'groupBodyCreate');\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/groups',\n            queryParams,\n            bodyParam: groupBodyCreate\n        });\n    }\n\n    /**\n     * Create a group membership\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.\n     *\n     * Create a group membership (for an existing person or group) within a group **groupId**.\n     * If the added group was previously a root group then it becomes a non-root group since it now has a parent.\n     * It is an error to specify an **id** that does not exist.\n     * You must have admin rights to create a group membership.\n     *\n     * @param groupId The identifier of a group.\n     * @param groupMembershipBodyCreate The group membership to add (person or sub-group).\n     * @param opts Optional parameters\n     * @returns Promise<GroupMemberEntry>\n     */\n    createGroupMembership(\n        groupId: string,\n        groupMembershipBodyCreate: GroupMembershipBodyCreate,\n        opts?: ContentFieldsQuery\n    ): Promise<GroupMemberEntry> {\n        throwIfNotDefined(groupId, 'groupId');\n        throwIfNotDefined(groupMembershipBodyCreate, 'groupMembershipBodyCreate');\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/groups/{groupId}/members',\n            pathParams: { groupId },\n            queryParams,\n            bodyParam: groupMembershipBodyCreate\n        });\n    }\n\n    /**\n     * Delete a group\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.\n     *\n     * Delete group **groupId**.\n     * The option to cascade delete applies this recursively to any hierarchy of group members.\n     * In this case, removing a group member does not delete the person or sub-group itself.\n     * If a removed sub-group no longer has any parent groups then it becomes a root group.\n     * You must have admin rights to delete a group.\n     *\n     * @param groupId The identifier of a group.\n     * @param opts Optional parameters\n     * @returns Promise\n     */\n    deleteGroup(groupId: string, opts?: DeleteGroupOpts): Promise<void> {\n        throwIfNotDefined(groupId, 'groupId');\n        opts = opts || {};\n\n        const cascadeDelete = opts['cascade'] ? opts['cascade'] : false;\n\n        const pathParams = {\n            groupId\n        };\n\n        const queryParams = {\n            cascade: cascadeDelete\n        };\n\n        return this.delete({\n            path: '/groups/{groupId}',\n            pathParams,\n            queryParams\n        });\n    }\n\n    /**\n     * Delete a group membership\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.\n     *\n     * Delete group member **groupMemberId** (person or sub-group) from group **groupId**.\n     * Removing a group member does not delete the person or sub-group itself.\\\n     * If a removed sub-group no longer has any parent groups then it becomes a root group.\n     *\n     * @param groupId The identifier of a group.\n     * @param groupMemberId The identifier of a person or group.\n     * @returns Promise<{}>\n     */\n    deleteGroupMembership(groupId: string, groupMemberId: string): Promise<void> {\n        throwIfNotDefined(groupId, 'groupId');\n        throwIfNotDefined(groupMemberId, 'groupMemberId');\n\n        const pathParams = {\n            groupId,\n            groupMemberId\n        };\n\n        return this.delete({\n            path: '/groups/{groupId}/members/{groupMemberId}',\n            pathParams\n        });\n    }\n\n    /**\n     * Get group details\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.\n     *\n     * Get details for group **groupId**.\n     * You can use the **include** parameter to return additional information.\n     *\n     * @param groupId The identifier of a group.\n     * @param opts Optional parameters\n     * @returns Promise<GroupEntry>\n     */\n    getGroup(groupId: string, opts?: ContentIncludeQuery & ContentFieldsQuery): Promise<GroupEntry> {\n        throwIfNotDefined(groupId, 'groupId');\n\n        const pathParams = {\n            groupId\n        };\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/groups/{groupId}',\n            pathParams,\n            queryParams\n        });\n    }\n\n    /**\n     * List memberships of a group\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.\n     *\n     * Gets a list of the group memberships for the group **groupId**.\n     *\n     * You can use the **where** parameter to filter the returned groups by **memberType**.\n     * Example to filter by **memberType**, use any one of:\n     * - (memberType='GROUP')\n     * - (memberType='PERSON')\n     *\n     * The default sort order for the returned list is for group members to be sorted by ascending displayName.\n     * You can override the default by using the **orderBy** parameter. You can specify one of the following fields in the **orderBy** parameter:\n     * - id\n     * - displayName\n     *\n     * @param groupId The identifier of a group.\n     * @param opts Optional parameters\n     * @returns Promise<GroupMemberPaging>\n     */\n    listGroupMemberships(groupId: string, opts?: ListGroupMembershipsOpts & ContentPagingQuery & ContentFieldsQuery): Promise<GroupMemberPaging> {\n        throwIfNotDefined(groupId, 'groupId');\n\n        const pathParams = {\n            groupId\n        };\n\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),\n            where: opts?.where,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/groups/{groupId}/members',\n            pathParams,\n            queryParams,\n            returnType: GroupMemberPaging\n        });\n    }\n\n    /**\n     * List group memberships\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.\n     *\n     * @param personId The identifier of a person.\n     * @param opts Optional parameters\n     * @param opts.skipCount The number of entities that exist in the collection before those included in this list.\n     * If not supplied then the default value is 0. (default to 0)\n     * @param opts.maxItems The maximum number of items to return in the list. If not supplied then the default value is 100. (default to 100)\n     * @param opts.orderBy A string to control the order of the entities returned in a list. You can use the **orderBy** parameter to\n     * sort the list by one or more fields.\n     * Each field has a default sort order, which is normally ascending order. Read the API method implementation notes\n     * above to check if any fields used in this method have a descending default search order.\n     * To sort the entities in a specific order, you can use the **ASC** and **DESC** keywords for any field.\n     * @param opts.include Returns additional information about the group. The following optional fields can be requested:\n     * - parentIds\n     * - zones\n     * @param opts.where A string to restrict the returned objects by using a predicate.\n     * @param opts.fields A list of field names.\n     * You can use this parameter to restrict the fields\n     * returned within a response if, for example, you want to save on overall bandwidth.\n     * The list applies to a returned individual entity or entries within a collection.\n     * If the API method also supports the **include** parameter, then the fields specified in the **include**\n     * parameter are returned in addition to those specified in the **fields** parameter.\n     * @returns Promise<GroupPaging>\n     */\n    listGroupMembershipsForPerson(\n        personId: string,\n        opts?: GroupPagingOpts & ContentPagingQuery & ContentIncludeQuery & ContentFieldsQuery\n    ): Promise<GroupPaging> {\n        throwIfNotDefined(personId, 'personId');\n\n        const pathParams = {\n            personId\n        };\n\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),\n            include: buildCollectionParam(opts?.include, 'csv'),\n            where: opts?.where,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/people/{personId}/groups',\n            pathParams,\n            queryParams,\n            returnType: GroupPaging\n        });\n    }\n\n    /**\n     * List groups\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.\n     *\n     * @param opts Optional parameters\n     * @returns Promise<GroupPaging>\n     */\n    listGroups(opts?: GroupPagingOpts & ContentPagingQuery & ContentIncludeQuery & ContentFieldsQuery): Promise<GroupPaging> {\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),\n            include: buildCollectionParam(opts?.include, 'csv'),\n            where: opts?.where,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/groups',\n            queryParams,\n            returnType: GroupPaging\n        });\n    }\n\n    /**\n     * Update group details\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.\n     * You must have admin rights to update a group.\n     *\n     * @param groupId The identifier of a group.\n     * @param groupBodyUpdate The group information to update.\n     * @param opts Optional parameters\n     * @returns Promise<GroupEntry>\n     */\n    updateGroup(groupId: string, groupBodyUpdate: GroupBodyUpdate, opts?: ContentIncludeQuery & ContentFieldsQuery): Promise<GroupEntry> {\n        throwIfNotDefined(groupId, 'groupId');\n        throwIfNotDefined(groupBodyUpdate, 'groupBodyUpdate');\n\n        const pathParams = {\n            groupId\n        };\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.put({\n            path: '/groups/{groupId}',\n            pathParams,\n            queryParams,\n            bodyParam: groupBodyUpdate\n        });\n    }\n}\n"]}

package/esm2020/api/content-rest-api/api/index.mjs

@@ -0,0 +1,39 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './types';
+export * from './actions.api';
+export * from './activities.api';
+export * from './audit.api';
+export * from './categories.api';
+export * from './comments.api';
+export * from './downloads.api';
+export * from './favorites.api';
+export * from './groups.api';
+export * from './networks.api';
+export * from './nodes.api';
+export * from './people.api';
+export * from './preferences.api';
+export * from './probes.api';
+export * from './queries.api';
+export * from './ratings.api';
+export * from './renditions.api';
+export * from './sharedlinks.api';
+export * from './sites.api';
+export * from './tags.api';
+export * from './trashcan.api';
+export * from './versions.api';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/content-rest-api/api/networks.api.mjs

@@ -0,0 +1,103 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { PersonNetworkEntry } from '../model/personNetworkEntry';
+import { PersonNetworkPaging } from '../model/personNetworkPaging';
+import { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+/**
+ * Networks service.
+ */
+export class NetworksApi extends BaseApi {
+    /**
+     * Get a network
+     *
+     * @param networkId The identifier of a network.
+     * @param opts Optional parameters
+     * @returns Promise<PersonNetworkEntry>
+     */
+    getNetwork(networkId, opts) {
+        throwIfNotDefined(networkId, 'networkId');
+        const pathParams = {
+            networkId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/networks/{networkId}',
+            pathParams,
+            queryParams,
+            returnType: PersonNetworkEntry
+        });
+    }
+    /**
+     * Get network information
+     *
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param personId The identifier of a person.
+     * @param networkId The identifier of a network.
+     * @param opts Optional parameters
+     * @returns Promise<PersonNetworkEntry>
+     */
+    getNetworkForPerson(personId, networkId, opts) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(networkId, 'networkId');
+        const pathParams = {
+            personId,
+            networkId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/people/{personId}/networks/{networkId}',
+            pathParams,
+            queryParams,
+            returnType: PersonNetworkEntry
+        });
+    }
+    /**
+     * List network membership
+     *
+     * Gets a list of network memberships for person **personId**.
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param personId The identifier of a person.
+     * @param opts Optional parameters
+     * @returns Promise<PersonNetworkPaging>
+     */
+    listNetworksForPerson(personId, opts) {
+        throwIfNotDefined(personId, 'personId');
+        const pathParams = {
+            personId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/people/{personId}/networks',
+            pathParams,
+            queryParams,
+            returnType: PersonNetworkPaging
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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