@alfresco/js-api 7.3.0-1529 → 7.3.0

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

@@ -0,0 +1,852 @@
+/*!
+ * @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 { SiteContainerPaging, SiteEntry, SiteGroupEntry, SiteGroupPaging, SiteMemberEntry, SiteMemberPaging, SiteMembershipRequestEntry, SiteMembershipRequestPaging, SiteMembershipRequestWithPersonPaging, SitePaging, SiteRoleEntry, SiteRolePaging } from '../model';
+import { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+/**
+ * Sites service.
+ */
+export class SitesApi extends BaseApi {
+    /**
+     * Approve a site membership request
+     *
+     * @param siteId The identifier of a site.
+     * @param inviteeId The invitee username.
+     * @param opts Optional parameters
+     * @param opts.siteMembershipApprovalBody Accepting a request to join, optionally, allows assignment of a role to the user.
+     * @returns Promise<{}>
+     */
+    approveSiteMembershipRequest(siteId, inviteeId, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(inviteeId, 'inviteeId');
+        const postBody = opts?.siteMembershipApprovalBody;
+        const pathParams = {
+            siteId,
+            inviteeId
+        };
+        return this.post({
+            path: '/sites/{siteId}/site-membership-requests/{inviteeId}/approve',
+            pathParams,
+            bodyParam: postBody
+        });
+    }
+    /**
+     * Create a site
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * @param siteBodyCreate The site details
+     * @param opts Optional parameters
+     * @param opts.skipConfiguration Flag to indicate whether the Share-specific (surf) configuration files for the site should not be created. (default to false)
+     * @param opts.skipAddToFavorites Flag to indicate whether the site should not be added to the user's site favorites. (default to false)
+     * @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<SiteEntry>
+     */
+    createSite(siteBodyCreate, opts) {
+        throwIfNotDefined(siteBodyCreate, 'siteBodyCreate');
+        opts = opts || {};
+        const queryParams = {
+            skipConfiguration: opts?.skipConfiguration,
+            skipAddToFavorites: opts?.skipAddToFavorites,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/sites',
+            queryParams,
+            bodyParam: siteBodyCreate,
+            returnType: SiteEntry
+        });
+    }
+    /**
+     * Create a site membership
+     *
+     * @param siteId The identifier of a site.
+     * @param siteMembershipBodyCreate The person to add and their role
+     * @param opts Optional parameters
+     * @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<SiteMemberEntry>
+     */
+    createSiteMembership(siteId, siteMembershipBodyCreate, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(siteMembershipBodyCreate, 'siteMembershipBodyCreate');
+        const pathParams = {
+            siteId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/sites/{siteId}/members',
+            pathParams,
+            queryParams,
+            bodyParam: siteMembershipBodyCreate,
+            returnType: SiteMemberEntry
+        });
+    }
+    /**
+     * Create a site membership request
+     *
+     * @param personId The identifier of a person.
+     * @param siteMembershipRequestBodyCreate Site membership request details
+     * @param opts Optional parameters
+     * @returns Promise<SiteMembershipRequestEntry>
+     */
+    createSiteMembershipRequestForPerson(personId, siteMembershipRequestBodyCreate, opts) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(siteMembershipRequestBodyCreate, 'siteMembershipRequestBodyCreate');
+        const pathParams = {
+            personId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/people/{personId}/site-membership-requests',
+            pathParams,
+            queryParams,
+            bodyParam: siteMembershipRequestBodyCreate,
+            returnType: SiteMembershipRequestEntry
+        });
+    }
+    /**
+     * Delete a site
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * @param siteId The identifier of a site.
+     * @param opts Optional parameters
+     * @param opts.permanent Flag to indicate whether the site should be permanently deleted i.e. bypass the trashcan. (default to false)
+     * @returns Promise<{}>
+     */
+    deleteSite(siteId, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        const pathParams = {
+            siteId
+        };
+        const queryParams = {
+            permanent: opts?.permanent
+        };
+        return this.delete({
+            path: '/sites/{siteId}',
+            pathParams,
+            queryParams
+        });
+    }
+    /**
+     * Delete a site membership
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param siteId The identifier of a site.
+     * @param personId The identifier of a person.
+     * @returns Promise<{}>
+     */
+    deleteSiteMembership(siteId, personId) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(personId, 'personId');
+        const pathParams = {
+            siteId,
+            personId
+        };
+        return this.delete({
+            path: '/sites/{siteId}/members/{personId}',
+            pathParams
+        });
+    }
+    /**
+     * Delete a site membership
+     *
+     * Deletes person **personId** as a member of site **siteId**.
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param personId The identifier of a person.
+     * @param siteId The identifier of a site.
+     * @returns Promise<{}>
+     */
+    deleteSiteMembershipForPerson(personId, siteId) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(siteId, 'siteId');
+        const pathParams = {
+            personId,
+            siteId
+        };
+        return this.delete({
+            path: '/people/{personId}/sites/{siteId}',
+            pathParams
+        });
+    }
+    /**
+     * Delete a site membership request
+     *
+     * Deletes the site membership request to site **siteId** 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 siteId The identifier of a site.
+     * @returns Promise<{}>
+     */
+    deleteSiteMembershipRequestForPerson(personId, siteId) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(siteId, 'siteId');
+        const pathParams = {
+            personId,
+            siteId
+        };
+        return this.delete({
+            path: '/people/{personId}/site-membership-requests/{siteId}',
+            pathParams
+        });
+    }
+    /**
+     * Get a site
+     *
+     * Gets information for site **siteId**.
+     *
+     * You can use the **relations** parameter to include one or more related
+     * entities in a single response and so reduce network traffic.
+     *
+     * The entity types in Alfresco are organized in a tree structure.
+     * The **sites** entity has two children, **containers** and **members**.
+     * The following relations parameter returns all the container and member
+     * objects related to the site **siteId**:
+     *
+     * containers,members
+     *
+     * @param siteId The identifier of a site.
+     * @param opts Optional parameters
+     * @param opts.relations Use the relations parameter to include one or more related entities in a single response.
+     * @returns Promise<SiteEntry>
+     */
+    getSite(siteId, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        const pathParams = {
+            siteId
+        };
+        const queryParams = {
+            relations: buildCollectionParam(opts?.relations, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/sites/{siteId}',
+            pathParams,
+            queryParams,
+            returnType: SiteEntry
+        });
+    }
+    /**
+     * Get a site container
+     *
+     * Gets information on the container **containerId** in site **siteId**.
+     *
+     * @param siteId The identifier of a site.
+     * @param containerId The unique identifier of a site container.
+     * @param opts Optional parameters
+     * @returns Promise<SiteContainerEntry>
+     */
+    getSiteContainer(siteId, containerId, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(containerId, 'containerId');
+        const pathParams = {
+            siteId,
+            containerId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/sites/{siteId}/containers/{containerId}',
+            pathParams,
+            queryParams
+        });
+    }
+    /**
+     * Get a site membership
+     *
+     * Gets site membership information for person **personId** on site **siteId**.
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param siteId The identifier of a site.
+     * @param personId The identifier of a person.
+     * @param opts Optional parameters
+     * @returns Promise<SiteMemberEntry>
+     */
+    getSiteMembership(siteId, personId, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(personId, 'personId');
+        const pathParams = {
+            siteId,
+            personId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/sites/{siteId}/members/{personId}',
+            pathParams,
+            queryParams,
+            returnType: SiteMemberEntry
+        });
+    }
+    /**
+     * Get a site membership
+     *
+     * Gets site membership information for person **personId** on site **siteId**.
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param personId The identifier of a person.
+     * @param siteId The identifier of a site.
+     * @returns Promise<SiteRoleEntry>
+     */
+    getSiteMembershipForPerson(personId, siteId) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(siteId, 'siteId');
+        const pathParams = {
+            personId,
+            siteId
+        };
+        return this.get({
+            path: '/people/{personId}/sites/{siteId}',
+            pathParams,
+            returnType: SiteRoleEntry
+        });
+    }
+    /**
+     * Get a site membership request
+     *
+     * Gets the site membership request for site **siteId** for person **personId**, if one exists.
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param personId The identifier of a person.
+     * @param siteId The identifier of a site.
+     * @param opts Optional parameters
+     * @returns Promise<SiteMembershipRequestEntry>
+     */
+    getSiteMembershipRequestForPerson(personId, siteId, opts) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(siteId, 'siteId');
+        const pathParams = {
+            personId,
+            siteId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/people/{personId}/site-membership-requests/{siteId}',
+            pathParams,
+            queryParams,
+            returnType: SiteMembershipRequestEntry
+        });
+    }
+    /**
+     * Get site membership requests
+     *
+     * You can use the **where** parameter to filter the returned site membership requests by **siteId**. For example:
+     *
+     * (siteId=mySite)
+     *
+     * The **where** parameter can also be used to filter by ***personId***. For example:
+     *
+     * where=(personId=person)
+     *
+     * This may be combined with the siteId filter, as shown below:
+     *
+     * where=(siteId=mySite AND personId=person))
+     *
+     * @param opts Optional parameters
+     * @param opts.where A string to restrict the returned objects by using a predicate.
+     * @returns Promise<SiteMembershipRequestWithPersonPaging>
+     */
+    getSiteMembershipRequests(opts) {
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            where: opts?.where,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/site-membership-requests',
+            queryParams,
+            returnType: SiteMembershipRequestWithPersonPaging
+        });
+    }
+    /**
+     * List site containers
+     *
+     * Gets a list of containers for the site **siteId**.
+     *
+     * @param siteId The identifier of a site.
+     * @param opts Optional parameters
+     * @returns Promise<SiteContainerPaging>
+     */
+    listSiteContainers(siteId, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        const pathParams = {
+            siteId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/sites/{siteId}/containers',
+            pathParams,
+            queryParams,
+            returnType: SiteContainerPaging
+        });
+    }
+    /**
+     * List site membership requests
+     *
+     * Gets a list of the current site membership requests 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<SiteMembershipRequestPaging>
+     */
+    listSiteMembershipRequestsForPerson(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}/site-membership-requests',
+            pathParams,
+            queryParams,
+            returnType: SiteMembershipRequestPaging
+        });
+    }
+    /**
+     * List site memberships
+     *
+     * Gets a list of site memberships for site **siteId**.
+     *
+     * @param siteId The identifier of a site.
+     * @param opts Optional parameters
+     * @returns Promise<SiteMemberPaging>
+     */
+    listSiteMemberships(siteId, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        opts = opts || {};
+        const pathParams = {
+            siteId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            where: opts?.where,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/sites/{siteId}/members',
+            pathParams,
+            queryParams,
+            returnType: SiteMemberPaging
+        });
+    }
+    /**
+     * List site memberships
+     *
+     * Gets a list of site membership information for person **personId**.
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * You can use the **where** parameter to filter the returned sites by **visibility** or site **preset**.
+     *
+     * Example to filter by **visibility**, use any one of:
+     * - (visibility='PRIVATE')
+     * - (visibility='PUBLIC')
+     * - (visibility='MODERATED')
+     *
+     * Example to filter by site **preset**:
+     *
+     * (preset='site-dashboard')
+     *
+     * The default sort order for the returned list is for sites to be sorted by ascending title.
+     * You can override the default by using the **orderBy** parameter. You can specify one or more of the following fields in the **orderBy** parameter:
+     * - id
+     * - title
+     * - role
+     *
+     * @param personId The identifier of a person.
+     * @param opts Optional parameters
+     * @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.relations Use the relations parameter to include one or more related entities in a single response.
+     * @param opts.where A string to restrict the returned objects by using a predicate.
+     * @returns Promise<SiteRolePaging>
+     */
+    listSiteMembershipsForPerson(personId, opts) {
+        throwIfNotDefined(personId, 'personId');
+        opts = opts || {};
+        const pathParams = {
+            personId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),
+            relations: buildCollectionParam(opts?.relations, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv'),
+            where: opts?.where
+        };
+        return this.get({
+            path: '/people/{personId}/sites',
+            pathParams,
+            queryParams,
+            returnType: SiteRolePaging
+        });
+    }
+    /**
+     * List sites
+     *
+     * Gets a list of sites in this repository.
+     *
+     * You can use the **where** parameter to filter the returned sites by **visibility** or site **preset**.
+     *
+     * Example to filter by **visibility**, use any one of:
+     *
+     * (visibility='PRIVATE')
+     * (visibility='PUBLIC')
+     * (visibility='MODERATED')
+     *
+     * Example to filter by site **preset**:
+     *
+     * (preset='site-dashboard')
+     *
+     * The default sort order for the returned list is for sites to be sorted by ascending title.
+     * You can override the default by using the **orderBy** parameter. You can specify one or more of the following fields in the **orderBy** parameter:
+     * id
+     * title
+     * description
+     *
+     * You can use the **relations** parameter to include one or more related
+     * entities in a single response and so reduce network traffic.
+     *
+     * The entity types in Alfresco are organized in a tree structure.
+     * The **sites** entity has two children, **containers** and **members**.
+     * The following relations parameter returns all the container and member
+     * objects related to each site:
+     *
+     * containers,members
+     *
+     *
+     * @param opts Optional parameters
+     * @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.relations Use the relations parameter to include one or more related entities in a single response.
+     * @param opts.where A string to restrict the returned objects by using a predicate.
+     * @returns Promise<SitePaging>
+     */
+    listSites(opts) {
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),
+            relations: buildCollectionParam(opts?.relations, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv'),
+            where: opts?.where
+        };
+        return this.get({
+            path: '/sites',
+            queryParams,
+            returnType: SitePaging
+        });
+    }
+    /**
+     * Reject a site membership request
+     *
+     * @param siteId The identifier of a site.
+     * @param inviteeId The invitee username.
+     * @param opts Optional parameters
+     * @param opts.siteMembershipRejectionBody Rejecting a request to join, optionally, allows the inclusion of comment.
+     * @returns Promise<{}>
+     */
+    rejectSiteMembershipRequest(siteId, inviteeId, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(inviteeId, 'inviteeId');
+        const postBody = opts?.siteMembershipRejectionBody;
+        const pathParams = {
+            siteId,
+            inviteeId
+        };
+        return this.post({
+            path: '/sites/{siteId}/site-membership-requests/{inviteeId}/reject',
+            pathParams,
+            bodyParam: postBody
+        });
+    }
+    /**
+     * Update a site
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * Update the details for the given site **siteId**. Site Manager or otherwise a
+     * (site) admin can update title, description or visibility.
+     *
+     * Note: the id of a site cannot be updated once the site has been created.
+     *
+     * @param siteId The identifier of a site.
+     * @param siteBodyUpdate The site information to update.
+     * @param opts Optional parameters
+     * @returns Promise<SiteEntry>
+     */
+    updateSite(siteId, siteBodyUpdate, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(siteBodyUpdate, 'siteBodyUpdate');
+        opts = opts || {};
+        const pathParams = {
+            siteId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/sites/{siteId}',
+            pathParams,
+            queryParams,
+            bodyParam: siteBodyUpdate,
+            returnType: SiteEntry
+        });
+    }
+    /**
+     * Update a site membership
+     *
+     * Update the membership of person **personId** in site **siteId**.
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     * You can set the **role** to one of four types:
+     * - SiteConsumer
+     * - SiteCollaborator
+     * - SiteContributor
+     * - SiteManager
+     *
+     * @param siteId The identifier of a site.
+     * @param personId The identifier of a person.
+     * @param siteMembershipBodyUpdate The persons new role
+     * @param opts Optional parameters
+     * @returns Promise<SiteMemberEntry>
+     */
+    updateSiteMembership(siteId, personId, siteMembershipBodyUpdate, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(siteMembershipBodyUpdate, 'siteMembershipBodyUpdate');
+        const pathParams = {
+            siteId,
+            personId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/sites/{siteId}/members/{personId}',
+            pathParams,
+            queryParams,
+            bodyParam: siteMembershipBodyUpdate,
+            returnType: SiteMemberEntry
+        });
+    }
+    /**
+     * Update a site membership request
+     *
+     * Updates the message for the site membership request to site **siteId** 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 siteId The identifier of a site.
+     * @param siteMembershipRequestBodyUpdate The new message to display
+     * @param opts Optional parameters
+     * @returns Promise<SiteMembershipRequestEntry>
+     */
+    updateSiteMembershipRequestForPerson(personId, siteId, siteMembershipRequestBodyUpdate, opts) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(siteMembershipRequestBodyUpdate, 'siteMembershipRequestBodyUpdate');
+        const pathParams = {
+            personId,
+            siteId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/people/{personId}/site-membership-requests/{siteId}',
+            pathParams,
+            queryParams,
+            bodyParam: siteMembershipRequestBodyUpdate,
+            returnType: SiteMembershipRequestEntry
+        });
+    }
+    /**
+     * Create a site membership for group
+     *
+     * **Note:** this endpoint is available in Alfresco 7.0.0 and newer versions.
+     * You can set the **role** to one of four types:
+     * - SiteConsumer
+     * - SiteCollaborator
+     * - SiteContributor
+     * - SiteManager
+     *
+     * @param siteId The identifier of a site.
+     * @param siteMembershipBodyCreate The group to add and it role
+     * @param opts Optional parameters
+     * @returns Promise<SiteGroupEntry>
+     */
+    createSiteGroupMembership(siteId, siteMembershipBodyCreate, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(siteMembershipBodyCreate, 'siteMembershipBodyCreate');
+        const pathParams = {
+            siteId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/sites/{siteId}/group-members',
+            pathParams,
+            queryParams,
+            bodyParam: siteMembershipBodyCreate,
+            returnType: SiteGroupEntry
+        });
+    }
+    /**
+     * List group membership for site
+     *
+     * **Note:** this endpoint is available in Alfresco 7.0.0 and newer versions.
+     *
+     * @param siteId The identifier of a site.
+     * @param opts Optional parameters
+     * @returns Promise<SiteGroupPaging>
+     */
+    listSiteGroups(siteId, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        const pathParams = {
+            siteId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/sites/{siteId}/group-members',
+            pathParams,
+            queryParams,
+            returnType: SiteGroupPaging
+        });
+    }
+    /**
+     * Get information about site membership of group
+     * **Note:** this endpoint is available in Alfresco 7.0.0 and newer versions.
+     * Gets site membership information for group **groupId** on site **siteId**.
+     *
+     * @param siteId The identifier of a site.
+     * @param groupId The authorityId of a group.
+     * @param opts Optional parameters
+     * @returns Promise<SiteGroupEntry>
+     */
+    getSiteGroupMembership(siteId, groupId, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(groupId, 'groupId');
+        const pathParams = {
+            siteId,
+            groupId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/sites/{siteId}/group-members/{groupId}',
+            pathParams,
+            queryParams,
+            returnType: SiteGroupEntry
+        });
+    }
+    /**
+     * Update site membership of group
+     *
+     * **Note:** this endpoint is available in Alfresco 7.0.0 and newer versions.
+     *
+     * You can set the **role** to one of four types:
+     * - SiteConsumer
+     * - SiteCollaborator
+     * - SiteContributor
+     * - SiteManager
+     *
+     * @param siteId The identifier of a site.
+     * @param groupId The authorityId of a group.
+     * @param siteMembershipBodyUpdate The group new role
+     * @param opts Optional parameters
+     * @returns Promise<SiteGroupEntry>
+     */
+    updateSiteGroupMembership(siteId, groupId, siteMembershipBodyUpdate, opts) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(groupId, 'groupId');
+        throwIfNotDefined(siteMembershipBodyUpdate, 'siteMembershipBodyUpdate');
+        const pathParams = {
+            siteId,
+            groupId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/sites/{siteId}/group-members/{groupId}',
+            pathParams,
+            queryParams,
+            bodyParam: siteMembershipBodyUpdate,
+            returnType: SiteGroupEntry
+        });
+    }
+    /**
+     * Delete a group membership for site
+     *
+     * @param siteId The identifier of a site.
+     * @param groupId The authorityId of a group.
+     * @returns Promise<{}>
+     */
+    deleteSiteGroupMembership(siteId, groupId) {
+        throwIfNotDefined(siteId, 'siteId');
+        throwIfNotDefined(groupId, 'groupId');
+        const pathParams = {
+            siteId,
+            groupId
+        };
+        return this.delete({
+            path: '/sites/{siteId}/group-members/{groupId}',
+            pathParams
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sites.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/content-rest-api/api/sites.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 {\n    SiteBodyCreate,\n    SiteBodyUpdate,\n    SiteContainerEntry,\n    SiteContainerPaging,\n    SiteEntry,\n    SiteGroupEntry,\n    SiteGroupPaging,\n    SiteMemberEntry,\n    SiteMemberPaging,\n    SiteMembershipBodyCreate,\n    SiteMembershipBodyUpdate,\n    SiteMembershipRequestBodyCreate,\n    SiteMembershipRequestBodyUpdate,\n    SiteMembershipRequestEntry,\n    SiteMembershipRequestPaging,\n    SiteMembershipRequestWithPersonPaging,\n    SitePaging,\n    SiteRoleEntry,\n    SiteRolePaging\n} from '../model';\nimport { BaseApi } from './base.api';\nimport { throwIfNotDefined } from '../../../assert';\nimport { buildCollectionParam } from '../../../alfrescoApiClient';\nimport { ContentFieldsQuery, ContentPagingQuery } from './types';\n\n/**\n * Sites service.\n */\nexport class SitesApi extends BaseApi {\n    /**\n     * Approve a site membership request\n     *\n     * @param siteId The identifier of a site.\n     * @param inviteeId The invitee username.\n     * @param opts Optional parameters\n     * @param opts.siteMembershipApprovalBody Accepting a request to join, optionally, allows assignment of a role to the user.\n     * @returns Promise<{}>\n     */\n    approveSiteMembershipRequest(siteId: string, inviteeId: string, opts?: { siteMembershipApprovalBody?: any }): Promise<any> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(inviteeId, 'inviteeId');\n\n        const postBody = opts?.siteMembershipApprovalBody;\n\n        const pathParams = {\n            siteId,\n            inviteeId\n        };\n\n        return this.post({\n            path: '/sites/{siteId}/site-membership-requests/{inviteeId}/approve',\n            pathParams,\n            bodyParam: postBody\n        });\n    }\n\n    /**\n     * Create a site\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * @param siteBodyCreate The site details\n     * @param opts Optional parameters\n     * @param opts.skipConfiguration Flag to indicate whether the Share-specific (surf) configuration files for the site should not be created. (default to false)\n     * @param opts.skipAddToFavorites Flag to indicate whether the site should not be added to the user's site favorites. (default to false)\n     * @param opts.fields A list of field names. 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<SiteEntry>\n     */\n    createSite(\n        siteBodyCreate: SiteBodyCreate,\n        opts?: { skipConfiguration?: boolean; skipAddToFavorites?: boolean; fields?: string[] }\n    ): Promise<SiteEntry> {\n        throwIfNotDefined(siteBodyCreate, 'siteBodyCreate');\n        opts = opts || {};\n\n        const queryParams = {\n            skipConfiguration: opts?.skipConfiguration,\n            skipAddToFavorites: opts?.skipAddToFavorites,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/sites',\n            queryParams,\n            bodyParam: siteBodyCreate,\n            returnType: SiteEntry\n        });\n    }\n\n    /**\n     * Create a site membership\n     *\n     * @param siteId The identifier of a site.\n     * @param siteMembershipBodyCreate The person to add and their role\n     * @param opts Optional parameters\n     * @param opts.fields A list of field names. You can use this parameter to restrict the fields\n     * returned within a response if, for example, you want to save on overall bandwidth. The list applies to a returned individual\n     * entity or entries within a collection. 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<SiteMemberEntry>\n     */\n    createSiteMembership(siteId: string, siteMembershipBodyCreate: SiteMembershipBodyCreate, opts?: { fields?: string[] }): Promise<SiteMemberEntry> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(siteMembershipBodyCreate, 'siteMembershipBodyCreate');\n\n        const pathParams = {\n            siteId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/sites/{siteId}/members',\n            pathParams,\n            queryParams,\n            bodyParam: siteMembershipBodyCreate,\n            returnType: SiteMemberEntry\n        });\n    }\n\n    /**\n     * Create a site membership request\n     *\n     * @param personId The identifier of a person.\n     * @param siteMembershipRequestBodyCreate Site membership request details\n     * @param opts Optional parameters\n     * @returns Promise<SiteMembershipRequestEntry>\n     */\n    createSiteMembershipRequestForPerson(\n        personId: string,\n        siteMembershipRequestBodyCreate: SiteMembershipRequestBodyCreate,\n        opts?: ContentFieldsQuery\n    ): Promise<SiteMembershipRequestEntry> {\n        throwIfNotDefined(personId, 'personId');\n        throwIfNotDefined(siteMembershipRequestBodyCreate, 'siteMembershipRequestBodyCreate');\n\n        const pathParams = {\n            personId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/people/{personId}/site-membership-requests',\n            pathParams,\n            queryParams,\n            bodyParam: siteMembershipRequestBodyCreate,\n            returnType: SiteMembershipRequestEntry\n        });\n    }\n\n    /**\n     * Delete a site\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * @param siteId The identifier of a site.\n     * @param opts Optional parameters\n     * @param opts.permanent Flag to indicate whether the site should be permanently deleted i.e. bypass the trashcan. (default to false)\n     * @returns Promise<{}>\n     */\n    deleteSite(siteId: string, opts?: { permanent?: boolean }): Promise<void> {\n        throwIfNotDefined(siteId, 'siteId');\n\n        const pathParams = {\n            siteId\n        };\n\n        const queryParams = {\n            permanent: opts?.permanent\n        };\n\n        return this.delete({\n            path: '/sites/{siteId}',\n            pathParams,\n            queryParams\n        });\n    }\n\n    /**\n     * Delete a site membership\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param siteId The identifier of a site.\n     * @param personId The identifier of a person.\n     * @returns Promise<{}>\n     */\n    deleteSiteMembership(siteId: string, personId: string): Promise<void> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(personId, 'personId');\n\n        const pathParams = {\n            siteId,\n            personId\n        };\n\n        return this.delete({\n            path: '/sites/{siteId}/members/{personId}',\n            pathParams\n        });\n    }\n\n    /**\n     * Delete a site membership\n     *\n     * Deletes person **personId** as a member of site **siteId**.\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param personId The identifier of a person.\n     * @param siteId The identifier of a site.\n     * @returns Promise<{}>\n     */\n    deleteSiteMembershipForPerson(personId: string, siteId: string): Promise<void> {\n        throwIfNotDefined(personId, 'personId');\n        throwIfNotDefined(siteId, 'siteId');\n\n        const pathParams = {\n            personId,\n            siteId\n        };\n\n        return this.delete({\n            path: '/people/{personId}/sites/{siteId}',\n            pathParams\n        });\n    }\n\n    /**\n     * Delete a site membership request\n     *\n     * Deletes the site membership request to site **siteId** for person **personId**.\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param personId The identifier of a person.\n     * @param siteId The identifier of a site.\n     * @returns Promise<{}>\n     */\n    deleteSiteMembershipRequestForPerson(personId: string, siteId: string): Promise<void> {\n        throwIfNotDefined(personId, 'personId');\n        throwIfNotDefined(siteId, 'siteId');\n\n        const pathParams = {\n            personId,\n            siteId\n        };\n\n        return this.delete({\n            path: '/people/{personId}/site-membership-requests/{siteId}',\n            pathParams\n        });\n    }\n\n    /**\n     * Get a site\n     *\n     * Gets information for site **siteId**.\n     *\n     * You can use the **relations** parameter to include one or more related\n     * entities in a single response and so reduce network traffic.\n     *\n     * The entity types in Alfresco are organized in a tree structure.\n     * The **sites** entity has two children, **containers** and **members**.\n     * The following relations parameter returns all the container and member\n     * objects related to the site **siteId**:\n     *\n     * containers,members\n     *\n     * @param siteId The identifier of a site.\n     * @param opts Optional parameters\n     * @param opts.relations Use the relations parameter to include one or more related entities in a single response.\n     * @returns Promise<SiteEntry>\n     */\n    getSite(siteId: string, opts?: { relations?: string[] } & ContentFieldsQuery): Promise<SiteEntry> {\n        throwIfNotDefined(siteId, 'siteId');\n\n        const pathParams = {\n            siteId\n        };\n\n        const queryParams = {\n            relations: buildCollectionParam(opts?.relations, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/sites/{siteId}',\n            pathParams,\n            queryParams,\n            returnType: SiteEntry\n        });\n    }\n\n    /**\n     * Get a site container\n     *\n     * Gets information on the container **containerId** in site **siteId**.\n     *\n     * @param siteId The identifier of a site.\n     * @param containerId The unique identifier of a site container.\n     * @param opts Optional parameters\n     * @returns Promise<SiteContainerEntry>\n     */\n    getSiteContainer(siteId: string, containerId: string, opts?: ContentFieldsQuery): Promise<SiteContainerEntry> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(containerId, 'containerId');\n\n        const pathParams = {\n            siteId,\n            containerId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/sites/{siteId}/containers/{containerId}',\n            pathParams,\n            queryParams\n        });\n    }\n\n    /**\n     * Get a site membership\n     *\n     * Gets site membership information for person **personId** on site **siteId**.\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param siteId The identifier of a site.\n     * @param personId The identifier of a person.\n     * @param opts Optional parameters\n     * @returns Promise<SiteMemberEntry>\n     */\n    getSiteMembership(siteId: string, personId: string, opts?: ContentFieldsQuery): Promise<SiteMemberEntry> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(personId, 'personId');\n\n        const pathParams = {\n            siteId,\n            personId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/sites/{siteId}/members/{personId}',\n            pathParams,\n            queryParams,\n            returnType: SiteMemberEntry\n        });\n    }\n\n    /**\n     * Get a site membership\n     *\n     * Gets site membership information for person **personId** on site **siteId**.\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param personId The identifier of a person.\n     * @param siteId The identifier of a site.\n     * @returns Promise<SiteRoleEntry>\n     */\n    getSiteMembershipForPerson(personId: string, siteId: string): Promise<SiteRoleEntry> {\n        throwIfNotDefined(personId, 'personId');\n        throwIfNotDefined(siteId, 'siteId');\n\n        const pathParams = {\n            personId,\n            siteId\n        };\n\n        return this.get({\n            path: '/people/{personId}/sites/{siteId}',\n            pathParams,\n            returnType: SiteRoleEntry\n        });\n    }\n\n    /**\n     * Get a site membership request\n     *\n     * Gets the site membership request for site **siteId** for person **personId**, if one exists.\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param personId The identifier of a person.\n     * @param siteId The identifier of a site.\n     * @param opts Optional parameters\n     * @returns Promise<SiteMembershipRequestEntry>\n     */\n    getSiteMembershipRequestForPerson(personId: string, siteId: string, opts?: ContentFieldsQuery): Promise<SiteMembershipRequestEntry> {\n        throwIfNotDefined(personId, 'personId');\n        throwIfNotDefined(siteId, 'siteId');\n\n        const pathParams = {\n            personId,\n            siteId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/people/{personId}/site-membership-requests/{siteId}',\n            pathParams,\n            queryParams,\n            returnType: SiteMembershipRequestEntry\n        });\n    }\n\n    /**\n     * Get site membership requests\n     *\n     * You can use the **where** parameter to filter the returned site membership requests by **siteId**. For example:\n     *\n     * (siteId=mySite)\n     *\n     * The **where** parameter can also be used to filter by ***personId***. For example:\n     *\n     * where=(personId=person)\n     *\n     * This may be combined with the siteId filter, as shown below:\n     *\n     * where=(siteId=mySite AND personId=person))\n     *\n     * @param opts Optional parameters\n     * @param opts.where A string to restrict the returned objects by using a predicate.\n     * @returns Promise<SiteMembershipRequestWithPersonPaging>\n     */\n    getSiteMembershipRequests(opts?: { where?: string } & ContentPagingQuery & ContentFieldsQuery): Promise<SiteMembershipRequestWithPersonPaging> {\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            where: opts?.where,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/site-membership-requests',\n            queryParams,\n            returnType: SiteMembershipRequestWithPersonPaging\n        });\n    }\n\n    /**\n     * List site containers\n     *\n     * Gets a list of containers for the site **siteId**.\n     *\n     * @param siteId The identifier of a site.\n     * @param opts Optional parameters\n     * @returns Promise<SiteContainerPaging>\n     */\n    listSiteContainers(siteId: string, opts?: ContentPagingQuery & ContentFieldsQuery): Promise<SiteContainerPaging> {\n        throwIfNotDefined(siteId, 'siteId');\n\n        const pathParams = {\n            siteId\n        };\n\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/sites/{siteId}/containers',\n            pathParams,\n            queryParams,\n            returnType: SiteContainerPaging\n        });\n    }\n\n    /**\n     * List site membership requests\n     *\n     * Gets a list of the current site membership requests for person **personId**.\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param personId The identifier of a person.\n     * @param opts Optional parameters\n     * @returns Promise<SiteMembershipRequestPaging>\n     */\n    listSiteMembershipRequestsForPerson(personId: string, opts?: ContentPagingQuery & ContentFieldsQuery): Promise<SiteMembershipRequestPaging> {\n        throwIfNotDefined(personId, 'personId');\n\n        const pathParams = {\n            personId\n        };\n\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/people/{personId}/site-membership-requests',\n            pathParams,\n            queryParams,\n            returnType: SiteMembershipRequestPaging\n        });\n    }\n\n    /**\n     * List site memberships\n     *\n     * Gets a list of site memberships for site **siteId**.\n     *\n     * @param siteId The identifier of a site.\n     * @param opts Optional parameters\n     * @returns Promise<SiteMemberPaging>\n     */\n    listSiteMemberships(siteId: string, opts?: { where?: string } & ContentPagingQuery & ContentFieldsQuery): Promise<SiteMemberPaging> {\n        throwIfNotDefined(siteId, 'siteId');\n\n        opts = opts || {};\n\n        const pathParams = {\n            siteId\n        };\n\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            where: opts?.where,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/sites/{siteId}/members',\n            pathParams,\n            queryParams,\n            returnType: SiteMemberPaging\n        });\n    }\n\n    /**\n     * List site memberships\n     *\n     * Gets a list of site membership information for person **personId**.\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * You can use the **where** parameter to filter the returned sites by **visibility** or site **preset**.\n     *\n     * Example to filter by **visibility**, use any one of:\n     * - (visibility='PRIVATE')\n     * - (visibility='PUBLIC')\n     * - (visibility='MODERATED')\n     *\n     * Example to filter by site **preset**:\n     *\n     * (preset='site-dashboard')\n     *\n     * The default sort order for the returned list is for sites to be sorted by ascending title.\n     * You can override the default by using the **orderBy** parameter. You can specify one or more of the following fields in the **orderBy** parameter:\n     * - id\n     * - title\n     * - role\n     *\n     * @param personId The identifier of a person.\n     * @param opts Optional parameters\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.relations Use the relations parameter to include one or more related entities in a single response.\n     * @param opts.where A string to restrict the returned objects by using a predicate.\n     * @returns Promise<SiteRolePaging>\n     */\n    listSiteMembershipsForPerson(\n        personId: string,\n        opts?: { where?: string; orderBy?: string[]; relations?: string[] } & ContentPagingQuery & ContentFieldsQuery\n    ): Promise<SiteRolePaging> {\n        throwIfNotDefined(personId, 'personId');\n        opts = opts || {};\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            relations: buildCollectionParam(opts?.relations, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv'),\n            where: opts?.where\n        };\n\n        return this.get({\n            path: '/people/{personId}/sites',\n            pathParams,\n            queryParams,\n            returnType: SiteRolePaging\n        });\n    }\n\n    /**\n     * List sites\n     *\n     * Gets a list of sites in this repository.\n     *\n     * You can use the **where** parameter to filter the returned sites by **visibility** or site **preset**.\n     *\n     * Example to filter by **visibility**, use any one of:\n     *\n     * (visibility='PRIVATE')\n     * (visibility='PUBLIC')\n     * (visibility='MODERATED')\n     *\n     * Example to filter by site **preset**:\n     *\n     * (preset='site-dashboard')\n     *\n     * The default sort order for the returned list is for sites to be sorted by ascending title.\n     * You can override the default by using the **orderBy** parameter. You can specify one or more of the following fields in the **orderBy** parameter:\n     * id\n     * title\n     * description\n     *\n     * You can use the **relations** parameter to include one or more related\n     * entities in a single response and so reduce network traffic.\n     *\n     * The entity types in Alfresco are organized in a tree structure.\n     * The **sites** entity has two children, **containers** and **members**.\n     * The following relations parameter returns all the container and member\n     * objects related to each site:\n     *\n     * containers,members\n     *\n     *\n     * @param opts Optional parameters\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.relations Use the relations parameter to include one or more related entities in a single response.\n     * @param opts.where A string to restrict the returned objects by using a predicate.\n     * @returns Promise<SitePaging>\n     */\n    listSites(\n        opts?: {\n            orderBy?: string[];\n            relations?: string[];\n            where?: string;\n        } & ContentPagingQuery &\n            ContentFieldsQuery\n    ): Promise<SitePaging> {\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),\n            relations: buildCollectionParam(opts?.relations, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv'),\n            where: opts?.where\n        };\n\n        return this.get({\n            path: '/sites',\n            queryParams,\n            returnType: SitePaging\n        });\n    }\n\n    /**\n     * Reject a site membership request\n     *\n     * @param siteId The identifier of a site.\n     * @param inviteeId The invitee username.\n     * @param opts Optional parameters\n     * @param opts.siteMembershipRejectionBody Rejecting a request to join, optionally, allows the inclusion of comment.\n     * @returns Promise<{}>\n     */\n    rejectSiteMembershipRequest(siteId: string, inviteeId: string, opts?: { siteMembershipRejectionBody?: any }): Promise<any> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(inviteeId, 'inviteeId');\n\n        const postBody = opts?.siteMembershipRejectionBody;\n\n        const pathParams = {\n            siteId,\n            inviteeId\n        };\n\n        return this.post({\n            path: '/sites/{siteId}/site-membership-requests/{inviteeId}/reject',\n            pathParams,\n            bodyParam: postBody\n        });\n    }\n\n    /**\n     * Update a site\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * Update the details for the given site **siteId**. Site Manager or otherwise a\n     * (site) admin can update title, description or visibility.\n     *\n     * Note: the id of a site cannot be updated once the site has been created.\n     *\n     * @param siteId The identifier of a site.\n     * @param siteBodyUpdate The site information to update.\n     * @param opts Optional parameters\n     * @returns Promise<SiteEntry>\n     */\n    updateSite(siteId: string, siteBodyUpdate: SiteBodyUpdate, opts?: ContentFieldsQuery): Promise<SiteEntry> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(siteBodyUpdate, 'siteBodyUpdate');\n\n        opts = opts || {};\n\n        const pathParams = {\n            siteId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.put({\n            path: '/sites/{siteId}',\n            pathParams,\n            queryParams,\n            bodyParam: siteBodyUpdate,\n            returnType: SiteEntry\n        });\n    }\n\n    /**\n     * Update a site membership\n     *\n     * Update the membership of person **personId** in site **siteId**.\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     * You can set the **role** to one of four types:\n     * - SiteConsumer\n     * - SiteCollaborator\n     * - SiteContributor\n     * - SiteManager\n     *\n     * @param siteId The identifier of a site.\n     * @param personId The identifier of a person.\n     * @param siteMembershipBodyUpdate The persons new role\n     * @param opts Optional parameters\n     * @returns Promise<SiteMemberEntry>\n     */\n    updateSiteMembership(\n        siteId: string,\n        personId: string,\n        siteMembershipBodyUpdate: SiteMembershipBodyUpdate,\n        opts?: ContentFieldsQuery\n    ): Promise<SiteMemberEntry> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(personId, 'personId');\n        throwIfNotDefined(siteMembershipBodyUpdate, 'siteMembershipBodyUpdate');\n\n        const pathParams = {\n            siteId,\n            personId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.put({\n            path: '/sites/{siteId}/members/{personId}',\n            pathParams,\n            queryParams,\n            bodyParam: siteMembershipBodyUpdate,\n            returnType: SiteMemberEntry\n        });\n    }\n\n    /**\n     * Update a site membership request\n     *\n     * Updates the message for the site membership request to site **siteId** for person **personId**.\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param personId The identifier of a person.\n     * @param siteId The identifier of a site.\n     * @param siteMembershipRequestBodyUpdate The new message to display\n     * @param opts Optional parameters\n     * @returns Promise<SiteMembershipRequestEntry>\n     */\n    updateSiteMembershipRequestForPerson(\n        personId: string,\n        siteId: string,\n        siteMembershipRequestBodyUpdate: SiteMembershipRequestBodyUpdate,\n        opts?: ContentFieldsQuery\n    ): Promise<SiteMembershipRequestEntry> {\n        throwIfNotDefined(personId, 'personId');\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(siteMembershipRequestBodyUpdate, 'siteMembershipRequestBodyUpdate');\n\n        const pathParams = {\n            personId,\n            siteId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.put({\n            path: '/people/{personId}/site-membership-requests/{siteId}',\n            pathParams,\n            queryParams,\n            bodyParam: siteMembershipRequestBodyUpdate,\n            returnType: SiteMembershipRequestEntry\n        });\n    }\n\n    /**\n     * Create a site membership for group\n     *\n     * **Note:** this endpoint is available in Alfresco 7.0.0 and newer versions.\n     * You can set the **role** to one of four types:\n     * - SiteConsumer\n     * - SiteCollaborator\n     * - SiteContributor\n     * - SiteManager\n     *\n     * @param siteId The identifier of a site.\n     * @param siteMembershipBodyCreate The group to add and it role\n     * @param opts Optional parameters\n     * @returns Promise<SiteGroupEntry>\n     */\n    createSiteGroupMembership(\n        siteId: string,\n        siteMembershipBodyCreate: SiteMembershipBodyCreate,\n        opts?: ContentFieldsQuery\n    ): Promise<SiteGroupEntry> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(siteMembershipBodyCreate, 'siteMembershipBodyCreate');\n\n        const pathParams = {\n            siteId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/sites/{siteId}/group-members',\n            pathParams,\n            queryParams,\n            bodyParam: siteMembershipBodyCreate,\n            returnType: SiteGroupEntry\n        });\n    }\n\n    /**\n     * List group membership for site\n     *\n     * **Note:** this endpoint is available in Alfresco 7.0.0 and newer versions.\n     *\n     * @param siteId The identifier of a site.\n     * @param opts Optional parameters\n     * @returns Promise<SiteGroupPaging>\n     */\n    listSiteGroups(siteId: string, opts?: ContentPagingQuery & ContentFieldsQuery): Promise<SiteGroupPaging> {\n        throwIfNotDefined(siteId, 'siteId');\n\n        const pathParams = {\n            siteId\n        };\n\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/sites/{siteId}/group-members',\n            pathParams,\n            queryParams,\n            returnType: SiteGroupPaging\n        });\n    }\n\n    /**\n     * Get information about site membership of group\n     * **Note:** this endpoint is available in Alfresco 7.0.0 and newer versions.\n     * Gets site membership information for group **groupId** on site **siteId**.\n     *\n     * @param siteId The identifier of a site.\n     * @param groupId The authorityId of a group.\n     * @param opts Optional parameters\n     * @returns Promise<SiteGroupEntry>\n     */\n    getSiteGroupMembership(siteId: string, groupId: string, opts?: ContentFieldsQuery): Promise<SiteGroupEntry> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(groupId, 'groupId');\n\n        const pathParams = {\n            siteId,\n            groupId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/sites/{siteId}/group-members/{groupId}',\n            pathParams,\n            queryParams,\n            returnType: SiteGroupEntry\n        });\n    }\n\n    /**\n     * Update site membership of group\n     *\n     * **Note:** this endpoint is available in Alfresco 7.0.0 and newer versions.\n     *\n     * You can set the **role** to one of four types:\n     * - SiteConsumer\n     * - SiteCollaborator\n     * - SiteContributor\n     * - SiteManager\n     *\n     * @param siteId The identifier of a site.\n     * @param groupId The authorityId of a group.\n     * @param siteMembershipBodyUpdate The group new role\n     * @param opts Optional parameters\n     * @returns Promise<SiteGroupEntry>\n     */\n    updateSiteGroupMembership(\n        siteId: string,\n        groupId: string,\n        siteMembershipBodyUpdate: SiteMembershipBodyUpdate,\n        opts?: ContentFieldsQuery\n    ): Promise<SiteGroupEntry> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(groupId, 'groupId');\n        throwIfNotDefined(siteMembershipBodyUpdate, 'siteMembershipBodyUpdate');\n\n        const pathParams = {\n            siteId,\n            groupId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.put({\n            path: '/sites/{siteId}/group-members/{groupId}',\n            pathParams,\n            queryParams,\n            bodyParam: siteMembershipBodyUpdate,\n            returnType: SiteGroupEntry\n        });\n    }\n\n    /**\n     * Delete a group membership for site\n     *\n     * @param siteId The identifier of a site.\n     * @param groupId The authorityId of a group.\n     * @returns Promise<{}>\n     */\n    deleteSiteGroupMembership(siteId: string, groupId: string): Promise<void> {\n        throwIfNotDefined(siteId, 'siteId');\n        throwIfNotDefined(groupId, 'groupId');\n\n        const pathParams = {\n            siteId,\n            groupId\n        };\n\n        return this.delete({\n            path: '/sites/{siteId}/group-members/{groupId}',\n            pathParams\n        });\n    }\n}\n"]}