@alfresco/js-api 7.3.0-1530 → 7.3.0

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

@@ -0,0 +1,780 @@
+/*!
+ * @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 { ChildAssociationEntry, DirectAccessUrlEntry, NodeAssociationPaging, NodeBodyCreate, NodeChildAssociationPaging, NodeEntry } from '../model';
+import { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+/**
+ * Nodes service.
+ */
+export class NodesApi extends BaseApi {
+    /**
+     * Copy a node
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * Copies the node **nodeId** to the parent folder node **targetParentId**. You specify the **targetParentId** in the request body.
+     *
+     * The new node has the same name as the source node unless you specify a new **name** in the request body.
+     *
+     * If the source **nodeId** is a folder, then all of its children are also copied.
+     *
+     * If the source **nodeId** is a file, it's properties, aspects and tags are copied, it's ratings, comments and locks are not.
+     *
+     * @param nodeId The identifier of a node.
+     * @param nodeBodyCopy The targetParentId and, optionally, a new name which should include the file extension.
+     * @param opts Optional parameters
+     * @returns Promise<NodeEntry>
+     */
+    copyNode(nodeId, nodeBodyCopy, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        throwIfNotDefined(nodeBodyCopy, 'nodeBodyCopy');
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/nodes/{nodeId}/copy',
+            pathParams,
+            queryParams,
+            bodyParam: nodeBodyCopy,
+            returnType: NodeEntry
+        });
+    }
+    /**
+     * Create node association
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * @param nodeId The identifier of a source node.
+     * @param associationBodyCreate The target node id and assoc type.
+     * @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<AssociationEntry>
+     */
+    createAssociation(nodeId, associationBodyCreate, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        throwIfNotDefined(associationBodyCreate, 'associationBodyCreate');
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/nodes/{nodeId}/targets',
+            pathParams,
+            queryParams,
+            bodyParam: associationBodyCreate
+        });
+    }
+    /**
+     * Create a node
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * @param nodeId The identifier of a node. You can also use one of these well-known aliases:
+     * -my-
+     * -shared-
+     * -root-
+     * @param nodeBodyCreate The node information to create.
+     * @param opts Optional parameters
+     * @param opts.autoRename If true, then  a name clash will cause an attempt to auto rename by finding a unique name using an integer suffix.
+     * @param opts.include Returns additional information about the node. The following optional fields can be requested:
+     * - allowableOperations
+     * - association
+     * - isLink
+     * - isFavorite
+     * - isLocked
+     * - path
+     * - permissions
+     * - definition
+     * @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.
+     * @param formParams parameters
+     * @returns Promise<NodeEntry>
+     */
+    createNode(nodeId, nodeBodyCreate, opts, formParams) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        throwIfNotDefined(nodeBodyCreate, 'nodeBodyCreate');
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            autoRename: opts?.autoRename,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        formParams = formParams || {};
+        let contentTypes;
+        let returnType;
+        if (formParams.filedata) {
+            contentTypes = ['multipart/form-data'];
+        }
+        else {
+            contentTypes = ['application/json'];
+            returnType = NodeEntry;
+        }
+        return this.post({
+            path: '/nodes/{nodeId}/children',
+            pathParams,
+            queryParams,
+            formParams,
+            bodyParam: nodeBodyCreate,
+            contentTypes,
+            returnType
+        });
+    }
+    /**
+     * Create a folder
+     *
+     * @param name - folder name
+     * @param relativePath - The relativePath specifies the folder structure to create relative to the node identified by nodeId.
+     * @param nodeId default value root.The identifier of a node where add the folder. You can also use one of these well-known aliases: -my- | -shared- | -root-
+     * @param opts Optional parameters
+     * @returns  A promise that is resolved if the folder is created and {error} if rejected.
+     */
+    createFolder(name, relativePath, nodeId, opts) {
+        nodeId = nodeId || '-root-';
+        const nodeBody = new NodeBodyCreate({
+            name,
+            relativePath,
+            nodeType: 'cm:folder'
+        });
+        return this.createNode(nodeId, nodeBody, opts);
+    }
+    /**
+     * Create secondary child
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * @param nodeId The identifier of a parent node.
+     * @param secondaryChildAssociationBodyCreate The child node id and assoc type.
+     * @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<ChildAssociationEntry>
+     */
+    createSecondaryChildAssociation(nodeId, secondaryChildAssociationBodyCreate, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        throwIfNotDefined(secondaryChildAssociationBodyCreate, 'secondaryChildAssociationBodyCreate');
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/nodes/{nodeId}/secondary-children',
+            pathParams,
+            queryParams,
+            bodyParam: secondaryChildAssociationBodyCreate,
+            returnType: ChildAssociationEntry
+        });
+    }
+    /**
+     * Delete node association(s)
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * Delete an association, or associations, from the source **nodeId* to a target node for the given association type.
+     * If the association type is **not** specified, then all peer associations, of any type, in the direction
+     * from source to target, are deleted.
+     * **Note:** After removal of the peer association, or associations, from source to target, the two nodes may still have peer associations in the other direction.
+     *
+     * @param nodeId The identifier of a source node.
+     * @param targetId The identifier of a target node.
+     * @param opts Optional parameters
+     * @param opts.assocType Only delete associations of this type.
+     * @returns Promise<{}>
+     */
+    deleteAssociation(nodeId, targetId, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        throwIfNotDefined(targetId, 'targetId');
+        const pathParams = {
+            nodeId,
+            targetId
+        };
+        const queryParams = {
+            assocType: opts?.assocType
+        };
+        return this.delete({
+            path: '/nodes/{nodeId}/targets/{targetId}',
+            pathParams,
+            queryParams
+        });
+    }
+    /**
+     * Delete a node
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * If **nodeId** is a folder, then its children are also deleted.
+     * Deleted nodes move to the trashcan unless the **permanent** query parameter is **true** and the current user is the owner of the node or an admin.
+     *
+     * Deleting a node deletes it from its primary parent and also from any secondary parents. Peer associations are also deleted, where the deleted
+     * node is either a source or target of an association. This applies recursively to any hierarchy of primary children of the deleted node.
+     *
+     * **Note:** If the node is not permanently deleted, and is later successfully restored to its former primary parent, then the primary
+     * child association is restored. This applies recursively for any primary children. No other secondary child associations or
+     * peer associations are restored for any of the nodes in the primary parent-child hierarchy of restored nodes, regardless of whether the original
+     * associations were to nodes inside or outside the restored hierarchy.
+     *
+     * @param nodeId The identifier of a node.
+     * @param opts Optional parameters
+     * @param opts.permanent If **true** then the node is deleted permanently, without moving to the trashcan.
+     * Only the owner of the node or an admin can permanently delete the node. (default to false)
+     * @returns Promise<{}>
+     */
+    deleteNode(nodeId, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            permanent: opts?.permanent
+        };
+        return this.delete({
+            path: '/nodes/{nodeId}',
+            pathParams,
+            queryParams
+        });
+    }
+    /**
+     * Delete multiple nodes
+     *
+     * @param nodeIds The list of node IDs to delete.
+     * @param opts Optional parameters
+     * @param opts.permanent If **true** then nodes are deleted permanently, without moving to the trashcan.
+     * Only the owner of the node or an admin can permanently delete the node. (default to false)
+     * @returns Promise<[]>
+     */
+    deleteNodes(nodeIds, opts) {
+        throwIfNotDefined(nodeIds, 'nodeIds');
+        return Promise.all(nodeIds.map((id) => this.deleteNode(id, opts)));
+    }
+    /**
+     * Delete secondary child or children
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * Delete secondary child associations between the parent **nodeId** and child nodes for the given association type.
+     *
+     * If the association type is **not** specified, then all secondary child associations, of any type in the direction
+     * from parent to secondary child, will be deleted. The child will still have a primary parent and may still be
+     * associated as a secondary child with other secondary parents.
+     *
+     * @param nodeId The identifier of a parent node.
+     * @param childId The identifier of a child node.
+     * @param opts Optional parameters
+     * @param opts.assocType Only delete associations of this type.
+     * @returns Promise<{}>
+     */
+    deleteSecondaryChildAssociation(nodeId, childId, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        throwIfNotDefined(childId, 'childId');
+        const pathParams = {
+            nodeId,
+            childId
+        };
+        return this.delete({
+            path: '/nodes/{nodeId}/secondary-children/{childId}',
+            pathParams,
+            queryParams: opts
+        });
+    }
+    /**
+     * Get a node
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * You can use the **include** parameter to return additional information.
+     *
+     * @param nodeId The identifier of a node. You can also use one of these well-known aliases:
+     * - -my-
+     * - -shared-
+     * - -root-
+     * @param opts Optional parameters
+     * @param opts.relativePath A path relative to the **nodeId**. If you set this, information is returned on the node resolved by this path.
+     * @returns Promise<NodeEntry>
+     */
+    getNode(nodeId, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            relativePath: opts?.relativePath,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/nodes/{nodeId}',
+            pathParams,
+            queryParams,
+            returnType: NodeEntry
+        });
+    }
+    /**
+     * Get node content
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * @param nodeId The identifier of a node.
+     * @param opts Optional parameters
+     * @param opts.attachment **true** enables a web browser to download the file as an attachment.
+     * **false** means a web browser may preview the file in a new tab or window, but not download the file.
+     * You can only set this parameter to **false** if the content type of the file is in the supported list;
+     * for example, certain image files and PDF files.
+     * If the content type is not supported for preview, then a value of **false**  is ignored, and
+     * the attachment will be returned in the response. (default to true)
+     * @param opts.ifModifiedSince Only returns the content if it has been modified since the date provided.
+     * Use the date format defined by HTTP. For example, Wed, 09 Mar 2016 16:56:34 GMT.
+     * @param opts.range The Range header indicates the part of a document that the server should return.
+     * Single part request supported, for example: bytes=1-10.
+     * @returns Promise<Blob>
+     */
+    getNodeContent(nodeId, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        opts = opts || {};
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            attachment: opts?.attachment
+        };
+        const headerParams = {
+            'If-Modified-Since': opts?.ifModifiedSince,
+            Range: opts?.range
+        };
+        const accepts = ['application/octet-stream'];
+        return this.get({
+            path: '/nodes/{nodeId}/content',
+            pathParams,
+            queryParams,
+            headerParams,
+            accepts,
+            returnType: 'blob'
+        });
+    }
+    /**
+     * List node children
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * Gets a list of children of the parent node **nodeId**.
+     * Minimal information for each child is returned by default.
+     * You can use the **include** parameter to return additional information.
+     * The list of child nodes includes primary children and secondary children, if there are any.
+     * You can use the **include** parameter (include=association) to return child association details
+     * for each child, including the **assocTyp**e and the **isPrimary** flag.
+     *
+     * The default sort order for the returned list is for folders to be sorted before files, and by ascending name.
+     *
+     * You can override the default using **orderBy** to specify one or more fields to sort by. The default order is always ascending, but
+     * you can use an optional **ASC** or **DESC** modifier to specify an ascending or descending sort order.
+     *
+     * For example, specifying orderBy=name DESC returns a mixed folder/file list in descending **name** order.
+     * You can use any of the following fields to order the results:
+     * - isFolder
+     * - name
+     * - mimeType
+     * - nodeType
+     * - sizeInBytes
+     * - modifiedAt
+     * - createdAt
+     * - modifiedByUser
+     * - createdByUser
+     *
+     * @param nodeId The identifier of a node. You can also use one of these well-known aliases:
+     * - -my-
+     * - -shared-
+     * - -root-
+     * @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.where Optionally filter the list. Here are some examples:
+     * - where=(isFolder=true)
+     * - where=(isFile=true)
+     * - where=(nodeType='my:specialNodeType')
+     * - where=(nodeType='my:specialNodeType INCLUDESUBTYPES')
+     * - where=(isPrimary=true)
+     * - where=(assocType='my:specialAssocType')
+     * - where=(isPrimary=false and assocType='my:specialAssocType')
+     * @param opts.relativePath Return information on children in the folder resolved by this path. The path is relative to **nodeId**.
+     * @param opts.includeSource Also include **source** in addition to **entries** with folder information on the parent node – either the specified parent **nodeId**, or as resolved by **relativePath**.
+     * @returns Promise<NodeChildAssociationPaging>
+     */
+    listNodeChildren(nodeId, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),
+            where: opts?.where,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            relativePath: opts?.relativePath,
+            includeSource: opts?.includeSource,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/nodes/{nodeId}/children',
+            pathParams,
+            queryParams,
+            returnType: NodeChildAssociationPaging
+        });
+    }
+    /**
+     * List parents
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * Gets a list of parent nodes that are associated with the current child **nodeId**.
+     * The list includes both the primary parent and any secondary parents.
+     *
+     * @param nodeId The identifier of a child node. You can also use one of these well-known aliases:
+     * - -my-
+     * - -shared-
+     * - -root-
+     * @param opts Optional parameters
+     * @param opts.where Optionally filter the list by **assocType** and/or **isPrimary**. Here are some example filters:
+     * - where=(assocType='my:specialAssocType')
+     * - where=(isPrimary=true)
+     * - where=(isPrimary=false and assocType='my:specialAssocType')
+     * @param opts.includeSource Also include **source** (in addition to **entries**) with folder information on **nodeId**
+     * @returns Promise<NodeAssociationPaging>
+     */
+    listParents(nodeId, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        opts = opts || {};
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            where: opts?.where,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            includeSource: opts?.includeSource,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/nodes/{nodeId}/parents',
+            pathParams,
+            queryParams,
+            returnType: NodeAssociationPaging
+        });
+    }
+    /**
+     * List secondary children
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * Gets a list of secondary child nodes that are associated with the current parent **nodeId**, via a secondary child association.
+     *
+     * @param nodeId The identifier of a parent node. You can also use one of these well-known aliases:
+     * -my-
+     * -shared-
+     * -root-
+     * @param opts Optional parameters
+     * @param opts.where Optionally filter the list by assocType. Here's an example:
+     * - where=(assocType='my:specialAssocType')
+     * @param opts.includeSource Also include **source** (in addition to **entries**) with folder information on **nodeId**
+     * @returns Promise<NodeChildAssociationPaging>
+     */
+    listSecondaryChildren(nodeId, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        opts = opts || {};
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            where: opts?.where,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            includeSource: opts?.includeSource,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/nodes/{nodeId}/secondary-children',
+            pathParams,
+            queryParams,
+            returnType: NodeChildAssociationPaging
+        });
+    }
+    /**
+     * List source associations
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * @param nodeId The identifier of a target node.
+     * @param opts Optional parameters
+     * @param opts.where Optionally filter the list by **assocType**. Here's an example:
+     * - where=(assocType='my:specialAssocType')
+     * @returns Promise<NodeAssociationPaging>
+     */
+    listSourceAssociations(nodeId, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        opts = opts || {};
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            where: opts?.where,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/nodes/{nodeId}/sources',
+            pathParams,
+            queryParams,
+            returnType: NodeAssociationPaging
+        });
+    }
+    /**
+     * List target associations
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * Gets a list of target nodes that are associated with the current source **nodeId**.
+     *
+     * @param nodeId The identifier of a source node.
+     * @param opts Optional parameters
+     * @param opts.where Optionally filter the list by **assocType**. Here's an example:
+     * - where=(assocType='my:specialAssocType')
+     * @returns Promise<NodeAssociationPaging>
+     */
+    listTargetAssociations(nodeId, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        opts = opts || {};
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            where: opts?.where,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/nodes/{nodeId}/targets',
+            pathParams,
+            queryParams,
+            returnType: NodeAssociationPaging
+        });
+    }
+    /**
+     * Lock a node
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * If a lock on the node cannot be taken, then an error is returned.
+     *
+     * @param nodeId The identifier of a node.
+     * @param nodeBodyLock Lock details.
+     * @param opts Optional parameters
+     * @returns Promise<NodeEntry>
+     */
+    lockNode(nodeId, nodeBodyLock, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        throwIfNotDefined(nodeBodyLock, 'nodeBodyLock');
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/nodes/{nodeId}/lock',
+            pathParams,
+            queryParams,
+            bodyParam: nodeBodyLock,
+            returnType: NodeEntry
+        });
+    }
+    /**
+     * Move a node
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * The **targetParentId** is specified in the in request body.
+     * The moved node retains its name unless you specify a new **name** in the request body.
+     * If the source **nodeId** is a folder, then its children are also moved.
+     * The move will effectively change the primary parent.
+     *
+     * @param nodeId The identifier of a node.
+     * @param nodeBodyMove The targetParentId and, optionally, a new name which should include the file extension.
+     * @param opts Optional parameters
+     * @returns Promise<NodeEntry>
+     */
+    moveNode(nodeId, nodeBodyMove, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        throwIfNotDefined(nodeBodyMove, 'nodeBodyMove');
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/nodes/{nodeId}/move',
+            pathParams,
+            queryParams,
+            bodyParam: nodeBodyMove,
+            returnType: NodeEntry
+        });
+    }
+    /**
+     * Unlock a node
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * The current user must be the owner of the locks or have admin rights, otherwise an error is returned.
+     * If a lock on the node cannot be released, then an error is returned.
+     *
+     * @param nodeId The identifier of a node.
+     * @param opts Optional parameters
+     * @returns Promise<NodeEntry>
+     */
+    unlockNode(nodeId, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/nodes/{nodeId}/unlock',
+            pathParams,
+            queryParams,
+            returnType: NodeEntry
+        });
+    }
+    /**
+     * Update a node
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * @param nodeId The identifier of a node.
+     * @param nodeBodyUpdate The node information to update.
+     * @param opts Optional parameters
+     * @returns Promise<NodeEntry>
+     */
+    updateNode(nodeId, nodeBodyUpdate, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        throwIfNotDefined(nodeBodyUpdate, 'nodeBodyUpdate');
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/nodes/{nodeId}',
+            pathParams,
+            queryParams,
+            bodyParam: nodeBodyUpdate,
+            returnType: NodeEntry
+        });
+    }
+    /**
+     * Update node content
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * @param nodeId The identifier of a node.
+     * @param contentBodyUpdate The binary content
+     * @param opts Optional parameters
+     * @param opts.majorVersion If **true**, create a major version.
+     * Setting this parameter also enables versioning of this node, if it is not already versioned. (default to false)
+     * @param opts.comment Add a version comment which will appear in version history.
+     * Setting this parameter also enables versioning of this node, if it is not already versioned.
+     * @param opts.name Optional new name. This should include the file extension.
+     * The name must not contain spaces or the following special characters: * \" < > \\ / ? : and |.
+     * The character . must not be used at the end of the name.
+     * @returns Promise<NodeEntry>
+     */
+    updateNodeContent(nodeId, contentBodyUpdate, opts) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        throwIfNotDefined(contentBodyUpdate, 'contentBodyUpdate');
+        opts = opts || {};
+        const pathParams = {
+            nodeId
+        };
+        const queryParams = {
+            majorVersion: opts?.majorVersion,
+            comment: opts?.comment,
+            name: opts?.name,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/nodes/{nodeId}/content',
+            pathParams,
+            queryParams,
+            contentTypes: ['application/octet-stream'],
+            bodyParam: contentBodyUpdate,
+            returnType: NodeEntry
+        });
+    }
+    /**
+     * Generate a direct access content url for a given node
+     *
+     * **Note:** this endpoint is available in Alfresco 7.1 and newer versions.
+     *
+     * @param nodeId The identifier of a node.
+     * @returns Promise<DirectAccessUrlEntry>
+     */
+    requestDirectAccessUrl(nodeId) {
+        throwIfNotDefined(nodeId, 'nodeId');
+        const pathParams = {
+            nodeId
+        };
+        return this.post({
+            path: '/nodes/{nodeId}/request-direct-access-url',
+            pathParams,
+            returnType: DirectAccessUrlEntry
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodes.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/content-rest-api/api/nodes.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    AssociationBody,\n    AssociationEntry,\n    ChildAssociationBody,\n    ChildAssociationEntry,\n    DirectAccessUrlEntry,\n    NodeAssociationPaging,\n    NodeBodyCopy,\n    NodeBodyCreate,\n    NodeBodyLock,\n    NodeBodyMove,\n    NodeBodyUpdate,\n    NodeChildAssociationPaging,\n    NodeEntry\n} from '../model';\nimport { BaseApi } from './base.api';\nimport { throwIfNotDefined } from '../../../assert';\nimport { buildCollectionParam } from '../../../alfrescoApiClient';\nimport { ContentPagingQuery } from './types';\n\nexport type NodesIncludeQuery = {\n    /**\n     * Returns additional information about the node. The following optional fields can be requested:\n     * - allowableOperations\n     * - association\n     * - isLink\n     * - isFavorite\n     * - isLocked\n     * - path\n     * - permissions\n     * - definition\n     */\n    include?: string[];\n\n    /**\n     * A list of field names.\n     *\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     *\n     * The list applies to a returned individual\n     * entity or entries within a collection.\n     *\n     * If the API method also supports the **include**\n     * parameter, then the fields specified in the **include**\n     * parameter are returned in addition to those specified in the **fields** parameter.\n     */\n    fields?: string[];\n};\n\nexport interface CreateNodeOpts extends NodesIncludeQuery {\n    [key: string]: any;\n    // If true, then a name clash will cause an attempt to auto rename by finding a unique name using an integer suffix.\n    autoRename?: boolean;\n    // If true, then created node will be version 1.0 MAJOR. If false, then created node will be version 0.1 MINOR.\n    majorVersion?: boolean;\n    // If true, then created node will be versioned. If false, then created node will be unversioned and auto-versioning disabled.\n    versioningEnabled?: boolean;\n}\n\n/**\n * Nodes service.\n */\nexport class NodesApi extends BaseApi {\n    /**\n     * Copy a node\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * Copies the node **nodeId** to the parent folder node **targetParentId**. You specify the **targetParentId** in the request body.\n     *\n     * The new node has the same name as the source node unless you specify a new **name** in the request body.\n     *\n     * If the source **nodeId** is a folder, then all of its children are also copied.\n     *\n     * If the source **nodeId** is a file, it's properties, aspects and tags are copied, it's ratings, comments and locks are not.\n     *\n     * @param nodeId The identifier of a node.\n     * @param nodeBodyCopy The targetParentId and, optionally, a new name which should include the file extension.\n     * @param opts Optional parameters\n     * @returns Promise<NodeEntry>\n     */\n    copyNode(nodeId: string, nodeBodyCopy: NodeBodyCopy, opts?: NodesIncludeQuery): Promise<NodeEntry> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        throwIfNotDefined(nodeBodyCopy, 'nodeBodyCopy');\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/nodes/{nodeId}/copy',\n            pathParams,\n            queryParams,\n            bodyParam: nodeBodyCopy,\n            returnType: NodeEntry\n        });\n    }\n\n    /**\n     * Create node association\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * @param nodeId The identifier of a source node.\n     * @param associationBodyCreate The target node id and assoc type.\n     * @param opts Optional parameters\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<AssociationEntry>\n     */\n    createAssociation(nodeId: string, associationBodyCreate: AssociationBody, opts?: { fields?: string[] }): Promise<AssociationEntry> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        throwIfNotDefined(associationBodyCreate, 'associationBodyCreate');\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/nodes/{nodeId}/targets',\n            pathParams,\n            queryParams,\n            bodyParam: associationBodyCreate\n        });\n    }\n\n    /**\n     * Create a node\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * @param nodeId The identifier of a node. You can also use one of these well-known aliases:\n     * -my-\n     * -shared-\n     * -root-\n     * @param nodeBodyCreate The node information to create.\n     * @param opts Optional parameters\n     * @param opts.autoRename If true, then  a name clash will cause an attempt to auto rename by finding a unique name using an integer suffix.\n     * @param opts.include Returns additional information about the node. The following optional fields can be requested:\n     * - allowableOperations\n     * - association\n     * - isLink\n     * - isFavorite\n     * - isLocked\n     * - path\n     * - permissions\n     * - definition\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     * @param formParams parameters\n     * @returns Promise<NodeEntry>\n     */\n    createNode(nodeId: string, nodeBodyCreate: NodeBodyCreate, opts?: CreateNodeOpts, formParams?: any): Promise<NodeEntry | any> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        throwIfNotDefined(nodeBodyCreate, 'nodeBodyCreate');\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            autoRename: opts?.autoRename,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        formParams = formParams || {};\n\n        let contentTypes;\n        let returnType;\n\n        if (formParams.filedata) {\n            contentTypes = ['multipart/form-data'];\n        } else {\n            contentTypes = ['application/json'];\n            returnType = NodeEntry;\n        }\n\n        return this.post({\n            path: '/nodes/{nodeId}/children',\n            pathParams,\n            queryParams,\n            formParams,\n            bodyParam: nodeBodyCreate,\n            contentTypes,\n            returnType\n        });\n    }\n\n    /**\n     * Create a folder\n     *\n     * @param name - folder name\n     * @param relativePath - The relativePath specifies the folder structure to create relative to the node identified by nodeId.\n     * @param nodeId default value root.The identifier of a node where add the folder. You can also use one of these well-known aliases: -my- | -shared- | -root-\n     * @param opts Optional parameters\n     * @returns  A promise that is resolved if the folder is created and {error} if rejected.\n     */\n    createFolder(name: string, relativePath: string, nodeId: string, opts?: CreateNodeOpts): Promise<NodeEntry> {\n        nodeId = nodeId || '-root-';\n\n        const nodeBody = new NodeBodyCreate({\n            name,\n            relativePath,\n            nodeType: 'cm:folder'\n        });\n\n        return this.createNode(nodeId, nodeBody, opts);\n    }\n\n    /**\n     * Create secondary child\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * @param nodeId The identifier of a parent node.\n     * @param secondaryChildAssociationBodyCreate The child node id and assoc type.\n     * @param opts Optional parameters\n     * @param opts.fields A list of field names.\n     * You can use this parameter to restrict the fields 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<ChildAssociationEntry>\n     */\n    createSecondaryChildAssociation(\n        nodeId: string,\n        secondaryChildAssociationBodyCreate: ChildAssociationBody,\n        opts?: {\n            fields?: string[];\n        }\n    ): Promise<ChildAssociationEntry> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        throwIfNotDefined(secondaryChildAssociationBodyCreate, 'secondaryChildAssociationBodyCreate');\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/nodes/{nodeId}/secondary-children',\n            pathParams,\n            queryParams,\n            bodyParam: secondaryChildAssociationBodyCreate,\n            returnType: ChildAssociationEntry\n        });\n    }\n    /**\n     * Delete node association(s)\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * Delete an association, or associations, from the source **nodeId* to a target node for the given association type.\n     * If the association type is **not** specified, then all peer associations, of any type, in the direction\n     * from source to target, are deleted.\n     * **Note:** After removal of the peer association, or associations, from source to target, the two nodes may still have peer associations in the other direction.\n     *\n     * @param nodeId The identifier of a source node.\n     * @param targetId The identifier of a target node.\n     * @param opts Optional parameters\n     * @param opts.assocType Only delete associations of this type.\n     * @returns Promise<{}>\n     */\n    deleteAssociation(nodeId: string, targetId: string, opts?: { assocType?: string }): Promise<void> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        throwIfNotDefined(targetId, 'targetId');\n\n        const pathParams = {\n            nodeId,\n            targetId\n        };\n\n        const queryParams = {\n            assocType: opts?.assocType\n        };\n\n        return this.delete({\n            path: '/nodes/{nodeId}/targets/{targetId}',\n            pathParams,\n            queryParams\n        });\n    }\n    /**\n     * Delete a node\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * If **nodeId** is a folder, then its children are also deleted.\n     * Deleted nodes move to the trashcan unless the **permanent** query parameter is **true** and the current user is the owner of the node or an admin.\n     *\n     * Deleting a node deletes it from its primary parent and also from any secondary parents. Peer associations are also deleted, where the deleted\n     * node is either a source or target of an association. This applies recursively to any hierarchy of primary children of the deleted node.\n     *\n     * **Note:** If the node is not permanently deleted, and is later successfully restored to its former primary parent, then the primary\n     * child association is restored. This applies recursively for any primary children. No other secondary child associations or\n     * peer associations are restored for any of the nodes in the primary parent-child hierarchy of restored nodes, regardless of whether the original\n     * associations were to nodes inside or outside the restored hierarchy.\n     *\n     * @param nodeId The identifier of a node.\n     * @param opts Optional parameters\n     * @param opts.permanent If **true** then the node is deleted permanently, without moving to the trashcan.\n     * Only the owner of the node or an admin can permanently delete the node. (default to false)\n     * @returns Promise<{}>\n     */\n    deleteNode(nodeId: string, opts?: { permanent?: boolean }): Promise<void> {\n        throwIfNotDefined(nodeId, 'nodeId');\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            permanent: opts?.permanent\n        };\n\n        return this.delete({\n            path: '/nodes/{nodeId}',\n            pathParams,\n            queryParams\n        });\n    }\n    /**\n     * Delete multiple nodes\n     *\n     * @param nodeIds The list of node IDs to delete.\n     * @param opts Optional parameters\n     * @param opts.permanent If **true** then nodes are deleted permanently, without moving to the trashcan.\n     * Only the owner of the node or an admin can permanently delete the node. (default to false)\n     * @returns Promise<[]>\n     */\n    deleteNodes(nodeIds: string[], opts?: { permanent?: boolean }): Promise<void[]> {\n        throwIfNotDefined(nodeIds, 'nodeIds');\n\n        return Promise.all(nodeIds.map((id) => this.deleteNode(id, opts)));\n    }\n\n    /**\n     * Delete secondary child or children\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * Delete secondary child associations between the parent **nodeId** and child nodes for the given association type.\n     *\n     * If the association type is **not** specified, then all secondary child associations, of any type in the direction\n     * from parent to secondary child, will be deleted. The child will still have a primary parent and may still be\n     * associated as a secondary child with other secondary parents.\n     *\n     * @param nodeId The identifier of a parent node.\n     * @param childId The identifier of a child node.\n     * @param opts Optional parameters\n     * @param opts.assocType Only delete associations of this type.\n     * @returns Promise<{}>\n     */\n    deleteSecondaryChildAssociation(nodeId: string, childId: string, opts?: { assocType?: string }): Promise<void> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        throwIfNotDefined(childId, 'childId');\n\n        const pathParams = {\n            nodeId,\n            childId\n        };\n\n        return this.delete({\n            path: '/nodes/{nodeId}/secondary-children/{childId}',\n            pathParams,\n            queryParams: opts\n        });\n    }\n\n    /**\n     * Get a node\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * You can use the **include** parameter to return additional information.\n     *\n     * @param nodeId The identifier of a node. You can also use one of these well-known aliases:\n     * - -my-\n     * - -shared-\n     * - -root-\n     * @param opts Optional parameters\n     * @param opts.relativePath A path relative to the **nodeId**. If you set this, information is returned on the node resolved by this path.\n     * @returns Promise<NodeEntry>\n     */\n    getNode(nodeId: string, opts?: { relativePath?: string } & NodesIncludeQuery): Promise<NodeEntry> {\n        throwIfNotDefined(nodeId, 'nodeId');\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            relativePath: opts?.relativePath,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/nodes/{nodeId}',\n            pathParams,\n            queryParams,\n            returnType: NodeEntry\n        });\n    }\n\n    /**\n     * Get node content\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * @param nodeId The identifier of a node.\n     * @param opts Optional parameters\n     * @param opts.attachment **true** enables a web browser to download the file as an attachment.\n     * **false** means a web browser may preview the file in a new tab or window, but not download the file.\n     * You can only set this parameter to **false** if the content type of the file is in the supported list;\n     * for example, certain image files and PDF files.\n     * If the content type is not supported for preview, then a value of **false**  is ignored, and\n     * the attachment will be returned in the response. (default to true)\n     * @param opts.ifModifiedSince Only returns the content if it has been modified since the date provided.\n     * Use the date format defined by HTTP. For example, Wed, 09 Mar 2016 16:56:34 GMT.\n     * @param opts.range The Range header indicates the part of a document that the server should return.\n     * Single part request supported, for example: bytes=1-10.\n     * @returns Promise<Blob>\n     */\n    getNodeContent(\n        nodeId: string,\n        opts?: {\n            attachment?: boolean;\n            ifModifiedSince?: string;\n            range?: string;\n        }\n    ): Promise<Blob> {\n        throwIfNotDefined(nodeId, 'nodeId');\n\n        opts = opts || {};\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            attachment: opts?.attachment\n        };\n\n        const headerParams = {\n            'If-Modified-Since': opts?.ifModifiedSince,\n            Range: opts?.range\n        };\n\n        const accepts = ['application/octet-stream'];\n\n        return this.get({\n            path: '/nodes/{nodeId}/content',\n            pathParams,\n            queryParams,\n            headerParams,\n            accepts,\n            returnType: 'blob'\n        });\n    }\n\n    /**\n     * List node children\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * Gets a list of children of the parent node **nodeId**.\n     * Minimal information for each child is returned by default.\n     * You can use the **include** parameter to return additional information.\n     * The list of child nodes includes primary children and secondary children, if there are any.\n     * You can use the **include** parameter (include=association) to return child association details\n     * for each child, including the **assocTyp**e and the **isPrimary** flag.\n     *\n     * The default sort order for the returned list is for folders to be sorted before files, and by ascending name.\n     *\n     * You can override the default using **orderBy** to specify one or more fields to sort by. The default order is always ascending, but\n     * you can use an optional **ASC** or **DESC** modifier to specify an ascending or descending sort order.\n     *\n     * For example, specifying orderBy=name DESC returns a mixed folder/file list in descending **name** order.\n     * You can use any of the following fields to order the results:\n     * - isFolder\n     * - name\n     * - mimeType\n     * - nodeType\n     * - sizeInBytes\n     * - modifiedAt\n     * - createdAt\n     * - modifiedByUser\n     * - createdByUser\n     *\n     * @param nodeId The identifier of a node. You can also use one of these well-known aliases:\n     * - -my-\n     * - -shared-\n     * - -root-\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 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.where Optionally filter the list. Here are some examples:\n     * - where=(isFolder=true)\n     * - where=(isFile=true)\n     * - where=(nodeType='my:specialNodeType')\n     * - where=(nodeType='my:specialNodeType INCLUDESUBTYPES')\n     * - where=(isPrimary=true)\n     * - where=(assocType='my:specialAssocType')\n     * - where=(isPrimary=false and assocType='my:specialAssocType')\n     * @param opts.relativePath Return information on children in the folder resolved by this path. The path is relative to **nodeId**.\n     * @param opts.includeSource Also include **source** in addition to **entries** with folder information on the parent node – either the specified parent **nodeId**, or as resolved by **relativePath**.\n     * @returns Promise<NodeChildAssociationPaging>\n     */\n    listNodeChildren(\n        nodeId: string,\n        opts?: {\n            orderBy?: string[];\n            where?: string;\n            relativePath?: string;\n            includeSource?: boolean;\n        } & NodesIncludeQuery &\n            ContentPagingQuery\n    ): Promise<NodeChildAssociationPaging> {\n        throwIfNotDefined(nodeId, 'nodeId');\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),\n            where: opts?.where,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            relativePath: opts?.relativePath,\n            includeSource: opts?.includeSource,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/nodes/{nodeId}/children',\n            pathParams,\n            queryParams,\n            returnType: NodeChildAssociationPaging\n        });\n    }\n\n    /**\n     * List parents\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * Gets a list of parent nodes that are associated with the current child **nodeId**.\n     * The list includes both the primary parent and any secondary parents.\n     *\n     * @param nodeId The identifier of a child node. You can also use one of these well-known aliases:\n     * - -my-\n     * - -shared-\n     * - -root-\n     * @param opts Optional parameters\n     * @param opts.where Optionally filter the list by **assocType** and/or **isPrimary**. Here are some example filters:\n     * - where=(assocType='my:specialAssocType')\n     * - where=(isPrimary=true)\n     * - where=(isPrimary=false and assocType='my:specialAssocType')\n     * @param opts.includeSource Also include **source** (in addition to **entries**) with folder information on **nodeId**\n     * @returns Promise<NodeAssociationPaging>\n     */\n    listParents(\n        nodeId: string,\n        opts?: {\n            where?: string;\n            includeSource?: boolean;\n        } & NodesIncludeQuery &\n            ContentPagingQuery\n    ): Promise<NodeAssociationPaging> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        opts = opts || {};\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            where: opts?.where,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            includeSource: opts?.includeSource,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/nodes/{nodeId}/parents',\n            pathParams,\n            queryParams,\n            returnType: NodeAssociationPaging\n        });\n    }\n\n    /**\n     * List secondary children\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * Gets a list of secondary child nodes that are associated with the current parent **nodeId**, via a secondary child association.\n     *\n     * @param nodeId The identifier of a parent node. You can also use one of these well-known aliases:\n     * -my-\n     * -shared-\n     * -root-\n     * @param opts Optional parameters\n     * @param opts.where Optionally filter the list by assocType. Here's an example:\n     * - where=(assocType='my:specialAssocType')\n     * @param opts.includeSource Also include **source** (in addition to **entries**) with folder information on **nodeId**\n     * @returns Promise<NodeChildAssociationPaging>\n     */\n    listSecondaryChildren(\n        nodeId: string,\n        opts?: {\n            where?: string;\n            includeSource?: boolean;\n        } & NodesIncludeQuery &\n            ContentPagingQuery\n    ): Promise<NodeChildAssociationPaging> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        opts = opts || {};\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            where: opts?.where,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            includeSource: opts?.includeSource,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/nodes/{nodeId}/secondary-children',\n            pathParams,\n            queryParams,\n            returnType: NodeChildAssociationPaging\n        });\n    }\n\n    /**\n     * List source associations\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * @param nodeId The identifier of a target node.\n     * @param opts Optional parameters\n     * @param opts.where Optionally filter the list by **assocType**. Here's an example:\n     * - where=(assocType='my:specialAssocType')\n     * @returns Promise<NodeAssociationPaging>\n     */\n    listSourceAssociations(\n        nodeId: string,\n        opts?: {\n            where?: string;\n        } & NodesIncludeQuery\n    ): Promise<NodeAssociationPaging> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        opts = opts || {};\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            where: opts?.where,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/nodes/{nodeId}/sources',\n            pathParams,\n            queryParams,\n            returnType: NodeAssociationPaging\n        });\n    }\n\n    /**\n     * List target associations\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * Gets a list of target nodes that are associated with the current source **nodeId**.\n     *\n     * @param nodeId The identifier of a source node.\n     * @param opts Optional parameters\n     * @param opts.where Optionally filter the list by **assocType**. Here's an example:\n     * - where=(assocType='my:specialAssocType')\n     * @returns Promise<NodeAssociationPaging>\n     */\n    listTargetAssociations(\n        nodeId: string,\n        opts?: {\n            where?: string;\n        } & NodesIncludeQuery &\n            ContentPagingQuery\n    ): Promise<NodeAssociationPaging> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        opts = opts || {};\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            where: opts?.where,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/nodes/{nodeId}/targets',\n            pathParams,\n            queryParams,\n            returnType: NodeAssociationPaging\n        });\n    }\n\n    /**\n     * Lock a node\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * If a lock on the node cannot be taken, then an error is returned.\n     *\n     * @param nodeId The identifier of a node.\n     * @param nodeBodyLock Lock details.\n     * @param opts Optional parameters\n     * @returns Promise<NodeEntry>\n     */\n    lockNode(nodeId: string, nodeBodyLock: NodeBodyLock, opts?: NodesIncludeQuery): Promise<NodeEntry> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        throwIfNotDefined(nodeBodyLock, 'nodeBodyLock');\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/nodes/{nodeId}/lock',\n            pathParams,\n            queryParams,\n            bodyParam: nodeBodyLock,\n            returnType: NodeEntry\n        });\n    }\n\n    /**\n     * Move a node\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * The **targetParentId** is specified in the in request body.\n     * The moved node retains its name unless you specify a new **name** in the request body.\n     * If the source **nodeId** is a folder, then its children are also moved.\n     * The move will effectively change the primary parent.\n     *\n     * @param nodeId The identifier of a node.\n     * @param nodeBodyMove The targetParentId and, optionally, a new name which should include the file extension.\n     * @param opts Optional parameters\n     * @returns Promise<NodeEntry>\n     */\n    moveNode(nodeId: string, nodeBodyMove: NodeBodyMove, opts?: NodesIncludeQuery): Promise<NodeEntry> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        throwIfNotDefined(nodeBodyMove, 'nodeBodyMove');\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/nodes/{nodeId}/move',\n            pathParams,\n            queryParams,\n            bodyParam: nodeBodyMove,\n            returnType: NodeEntry\n        });\n    }\n\n    /**\n     * Unlock a node\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * The current user must be the owner of the locks or have admin rights, otherwise an error is returned.\n     * If a lock on the node cannot be released, then an error is returned.\n     *\n     * @param nodeId The identifier of a node.\n     * @param opts Optional parameters\n     * @returns Promise<NodeEntry>\n     */\n    unlockNode(nodeId: string, opts?: NodesIncludeQuery): Promise<NodeEntry> {\n        throwIfNotDefined(nodeId, 'nodeId');\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/nodes/{nodeId}/unlock',\n            pathParams,\n            queryParams,\n            returnType: NodeEntry\n        });\n    }\n\n    /**\n     * Update a node\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * @param nodeId The identifier of a node.\n     * @param nodeBodyUpdate The node information to update.\n     * @param opts Optional parameters\n     * @returns Promise<NodeEntry>\n     */\n    updateNode(nodeId: string, nodeBodyUpdate: NodeBodyUpdate, opts?: NodesIncludeQuery): Promise<NodeEntry> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        throwIfNotDefined(nodeBodyUpdate, 'nodeBodyUpdate');\n\n        const pathParams = {\n            nodeId\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: '/nodes/{nodeId}',\n            pathParams,\n            queryParams,\n            bodyParam: nodeBodyUpdate,\n            returnType: NodeEntry\n        });\n    }\n    /**\n     * Update node content\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * @param nodeId The identifier of a node.\n     * @param contentBodyUpdate The binary content\n     * @param opts Optional parameters\n     * @param opts.majorVersion If **true**, create a major version.\n     * Setting this parameter also enables versioning of this node, if it is not already versioned. (default to false)\n     * @param opts.comment Add a version comment which will appear in version history.\n     * Setting this parameter also enables versioning of this node, if it is not already versioned.\n     * @param opts.name Optional new name. This should include the file extension.\n     * The name must not contain spaces or the following special characters: * \\\" < > \\\\ / ? : and |.\n     * The character . must not be used at the end of the name.\n     * @returns Promise<NodeEntry>\n     */\n    updateNodeContent(\n        nodeId: string,\n        contentBodyUpdate: string,\n        opts?: {\n            majorVersion?: boolean;\n            comment?: string;\n            name?: string;\n        } & NodesIncludeQuery\n    ): Promise<NodeEntry> {\n        throwIfNotDefined(nodeId, 'nodeId');\n        throwIfNotDefined(contentBodyUpdate, 'contentBodyUpdate');\n        opts = opts || {};\n\n        const pathParams = {\n            nodeId\n        };\n\n        const queryParams = {\n            majorVersion: opts?.majorVersion,\n            comment: opts?.comment,\n            name: opts?.name,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.put({\n            path: '/nodes/{nodeId}/content',\n            pathParams,\n            queryParams,\n            contentTypes: ['application/octet-stream'],\n            bodyParam: contentBodyUpdate,\n            returnType: NodeEntry\n        });\n    }\n\n    /**\n     * Generate a direct access content url for a given node\n     *\n     * **Note:** this endpoint is available in Alfresco 7.1 and newer versions.\n     *\n     * @param nodeId The identifier of a node.\n     * @returns Promise<DirectAccessUrlEntry>\n     */\n    requestDirectAccessUrl(nodeId: string): Promise<DirectAccessUrlEntry> {\n        throwIfNotDefined(nodeId, 'nodeId');\n\n        const pathParams = {\n            nodeId\n        };\n\n        return this.post({\n            path: '/nodes/{nodeId}/request-direct-access-url',\n            pathParams,\n            returnType: DirectAccessUrlEntry\n        });\n    }\n}\n"]}