@alfresco/js-api 7.3.0-1529 → 7.3.0

package/esm2020/api/gs-core-rest-api/api/recordFolders.api.mjs

@@ -0,0 +1,162 @@
+/*!
+ * @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 { RecordEntry, RecordFolderAssociationPaging, RecordFolderEntry } from '../model';
+import { BaseApi } from './base.api';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * Record Folders service.
+ */
+export class RecordFoldersApi extends BaseApi {
+    /**
+     * Create a record
+     *
+     * Create a record as a primary child of **recordFolderId**.
+     * This endpoint supports both JSON and multipart/form-data (file upload).
+     *
+     * @param recordFolderId The identifier of a record folder.
+     * @param recordBodyCreate The record information to create. This field is ignored for multipart/form-data content uploads.
+     * @param opts Optional parameters
+     * @returns Promise<RecordEntry>
+     */
+    createRecordFolderChild(recordFolderId, recordBodyCreate, opts) {
+        throwIfNotDefined(recordFolderId, 'recordFolderId');
+        throwIfNotDefined(recordBodyCreate, 'recordBodyCreate');
+        const pathParams = {
+            recordFolderId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/record-folders/{recordFolderId}/records',
+            pathParams,
+            queryParams,
+            bodyParam: recordBodyCreate,
+            returnType: RecordEntry
+        });
+    }
+    /**
+     * Deletes record folder **recordFolderId**.
+     * Deleted file plan components cannot be recovered, they are deleted permanently.
+     *
+     * @param recordFolderId The identifier of a record folder.
+     * @returns Promise<{}>
+     */
+    deleteRecordFolder(recordFolderId) {
+        throwIfNotDefined(recordFolderId, 'recordFolderId');
+        const pathParams = {
+            recordFolderId
+        };
+        return this.delete({
+            path: '/record-folders/{recordFolderId}',
+            pathParams
+        });
+    }
+    /**
+     * Get a record folder
+     *
+     * Mandatory fields and the record folder's aspects and properties are returned by default.
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param recordFolderId The identifier of a record folder.
+     * @param opts Optional parameters
+     * @returns Promise<RecordFolderEntry>
+     */
+    getRecordFolder(recordFolderId, opts) {
+        throwIfNotDefined(recordFolderId, 'recordFolderId');
+        const pathParams = {
+            recordFolderId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/record-folders/{recordFolderId}',
+            pathParams,
+            queryParams,
+            returnType: RecordFolderEntry
+        });
+    }
+    /**
+     * List records
+     *
+     * Minimal information for each record is returned by default.
+     * The list of records includes primary children and secondary children, if there are any.
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param recordFolderId The identifier of a record folder.
+     * @param opts Optional parameters
+     * @param opts.where Optionally filter the list. Here are some examples:
+     *   - where=(nodeType='my:specialNodeType')
+     *   - where=(nodeType='my:specialNodeType INCLUDESUBTYPES')
+     *   - where=(isPrimary=true)
+     * @returns Promise<RecordFolderAssociationPaging>
+     */
+    listRecordFolderChildren(recordFolderId, opts) {
+        throwIfNotDefined(recordFolderId, 'recordFolderId');
+        const pathParams = {
+            recordFolderId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            where: opts?.where,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            includeSource: opts?.includeSource,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/record-folders/{recordFolderId}/records',
+            pathParams,
+            queryParams,
+            returnType: RecordFolderAssociationPaging
+        });
+    }
+    /**
+     * Updates record folder **recordFolderId**. For example, you can rename a record folder:
+     *
+     * **Note:** if you want to add or remove aspects, then you must use **GET /record-folders/{recordFolderId}** first to get the complete set of *aspectNames*.
+     * **Note:** Currently there is no optimistic locking for updates, so they are applied in \"last one wins\" order.
+     *
+     * @param recordFolderId The identifier of a record folder.
+     * @param recordFolderBodyUpdate The record folder information to update.
+     * @param opts Optional parameters
+     * @returns Promise<RecordFolderEntry>
+     */
+    updateRecordFolder(recordFolderId, recordFolderBodyUpdate, opts) {
+        throwIfNotDefined(recordFolderId, 'recordFolderId');
+        throwIfNotDefined(recordFolderBodyUpdate, 'recordFolderBodyUpdate');
+        const pathParams = {
+            recordFolderId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/record-folders/{recordFolderId}',
+            pathParams,
+            queryParams,
+            bodyParam: recordFolderBodyUpdate,
+            returnType: RecordFolderEntry
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recordFolders.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/gs-core-rest-api/api/recordFolders.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 { FilePlanComponentBodyUpdate, RecordEntry, RecordFolderAssociationPaging, RecordFolderEntry, RMNodeBodyCreate } from '../model';\nimport { BaseApi } from './base.api';\nimport { buildCollectionParam } from '../../../alfrescoApiClient';\nimport { throwIfNotDefined } from '../../../assert';\nimport { RecordsIncludeQuery, RecordsPagingQuery, RecordsSourceQuery } from './types';\n\n/**\n * Record Folders service.\n */\nexport class RecordFoldersApi extends BaseApi {\n    /**\n     * Create a record\n     *\n     * Create a record as a primary child of **recordFolderId**.\n     * This endpoint supports both JSON and multipart/form-data (file upload).\n     *\n     * @param recordFolderId The identifier of a record folder.\n     * @param recordBodyCreate The record information to create. This field is ignored for multipart/form-data content uploads.\n     * @param opts Optional parameters\n     * @returns Promise<RecordEntry>\n     */\n    createRecordFolderChild(recordFolderId: string, recordBodyCreate: RMNodeBodyCreate, opts?: RecordsIncludeQuery): Promise<RecordEntry> {\n        throwIfNotDefined(recordFolderId, 'recordFolderId');\n        throwIfNotDefined(recordBodyCreate, 'recordBodyCreate');\n\n        const pathParams = {\n            recordFolderId\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: '/record-folders/{recordFolderId}/records',\n            pathParams,\n            queryParams,\n            bodyParam: recordBodyCreate,\n            returnType: RecordEntry\n        });\n    }\n\n    /**\n     * Deletes record folder **recordFolderId**.\n     * Deleted file plan components cannot be recovered, they are deleted permanently.\n     *\n     * @param recordFolderId The identifier of a record folder.\n     * @returns Promise<{}>\n     */\n    deleteRecordFolder(recordFolderId: string): Promise<void> {\n        throwIfNotDefined(recordFolderId, 'recordFolderId');\n\n        const pathParams = {\n            recordFolderId\n        };\n\n        return this.delete({\n            path: '/record-folders/{recordFolderId}',\n            pathParams\n        });\n    }\n\n    /**\n     * Get a record folder\n     *\n     * Mandatory fields and the record folder's aspects and properties are returned by default.\n     * You can use the **include** parameter (include=allowableOperations) to return additional information.\n     *\n     * @param recordFolderId The identifier of a record folder.\n     * @param opts Optional parameters\n     * @returns Promise<RecordFolderEntry>\n     */\n    getRecordFolder(recordFolderId: string, opts?: RecordsIncludeQuery): Promise<RecordFolderEntry> {\n        throwIfNotDefined(recordFolderId, 'recordFolderId');\n\n        const pathParams = {\n            recordFolderId\n        };\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/record-folders/{recordFolderId}',\n            pathParams,\n            queryParams,\n            returnType: RecordFolderEntry\n        });\n    }\n\n    /**\n     * List records\n     *\n     * Minimal information for each record is returned by default.\n     * The list of records includes primary children and secondary children, if there are any.\n     * You can use the **include** parameter (include=allowableOperations) to return additional information.\n     *\n     * @param recordFolderId The identifier of a record folder.\n     * @param opts Optional parameters\n     * @param opts.where Optionally filter the list. Here are some examples:\n     *   - where=(nodeType='my:specialNodeType')\n     *   - where=(nodeType='my:specialNodeType INCLUDESUBTYPES')\n     *   - where=(isPrimary=true)\n     * @returns Promise<RecordFolderAssociationPaging>\n     */\n    listRecordFolderChildren(\n        recordFolderId: string,\n        opts?: {\n            where?: string;\n        } & RecordsPagingQuery &\n            RecordsIncludeQuery &\n            RecordsSourceQuery\n    ): Promise<RecordFolderAssociationPaging> {\n        throwIfNotDefined(recordFolderId, 'recordFolderId');\n\n        const pathParams = {\n            recordFolderId\n        };\n\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            where: opts?.where,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            includeSource: opts?.includeSource,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/record-folders/{recordFolderId}/records',\n            pathParams,\n            queryParams,\n            returnType: RecordFolderAssociationPaging\n        });\n    }\n\n    /**\n     * Updates record folder **recordFolderId**. For example, you can rename a record folder:\n     *\n     * **Note:** if you want to add or remove aspects, then you must use **GET /record-folders/{recordFolderId}** first to get the complete set of *aspectNames*.\n     * **Note:** Currently there is no optimistic locking for updates, so they are applied in \\\"last one wins\\\" order.\n     *\n     * @param recordFolderId The identifier of a record folder.\n     * @param recordFolderBodyUpdate The record folder information to update.\n     * @param opts Optional parameters\n     * @returns Promise<RecordFolderEntry>\n     */\n    updateRecordFolder(\n        recordFolderId: string,\n        recordFolderBodyUpdate: FilePlanComponentBodyUpdate,\n        opts?: RecordsIncludeQuery\n    ): Promise<RecordFolderEntry> {\n        throwIfNotDefined(recordFolderId, 'recordFolderId');\n        throwIfNotDefined(recordFolderBodyUpdate, 'recordFolderBodyUpdate');\n\n        const pathParams = {\n            recordFolderId\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: '/record-folders/{recordFolderId}',\n            pathParams,\n            queryParams,\n            bodyParam: recordFolderBodyUpdate,\n            returnType: RecordFolderEntry\n        });\n    }\n}\n"]}

package/esm2020/api/gs-core-rest-api/api/records.api.mjs

@@ -0,0 +1,203 @@
+/*!
+ * @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 { RecordEntry } from '../model/recordEntry';
+import { BaseApi } from './base.api';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * Records service.
+ *
+ * @module RecordsApi
+ */
+export class RecordsApi extends BaseApi {
+    /**
+     * Complete a record
+     *
+     * @param recordId The identifier of a record.
+     * @param opts Optional parameters
+     * @returns Promise<RecordEntry>
+     */
+    completeRecord(recordId, opts) {
+        throwIfNotDefined(recordId, 'recordId');
+        const pathParams = {
+            recordId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/records/{recordId}/complete',
+            pathParams,
+            queryParams,
+            returnType: RecordEntry
+        });
+    }
+    /**
+     * Delete a record. Deleted file plan components cannot be recovered, they are deleted permanently.
+     *
+     * @param recordId The identifier of a record.
+     * @returns Promise<{}>
+     */
+    deleteRecord(recordId) {
+        throwIfNotDefined(recordId, 'recordId');
+        const pathParams = {
+            recordId
+        };
+        return this.delete({
+            path: '/records/{recordId}',
+            pathParams
+        });
+    }
+    /**
+     * File a record
+     *
+     * You need to specify the target record folder by providing its id **targetParentId**
+     * If the record is already filed, a link to the target record folder is created.
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param recordId The identifier of a record.
+     * @param nodeBodyFile The target record folder id
+     * @param opts Optional parameters
+     * @returns Promise<RecordEntry>
+     */
+    fileRecord(recordId, nodeBodyFile, opts) {
+        throwIfNotDefined(recordId, 'recordId');
+        throwIfNotDefined(nodeBodyFile, 'nodeBodyFile');
+        const pathParams = {
+            recordId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/records/{recordId}/file',
+            pathParams,
+            queryParams,
+            bodyParam: nodeBodyFile,
+            returnType: RecordEntry
+        });
+    }
+    /**
+     * Get a record
+     *
+     * Mandatory fields and the record's aspects and properties are returned by default.
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param recordId The identifier of a record.
+     * @param opts Optional parameters
+     * @returns Promise<RecordEntry>
+     */
+    getRecord(recordId, opts) {
+        throwIfNotDefined(recordId, 'recordId');
+        const pathParams = {
+            recordId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/records/{recordId}',
+            pathParams,
+            queryParams,
+            returnType: RecordEntry
+        });
+    }
+    /**
+     * Get record content
+     *
+     * @param recordId The identifier of a record.
+     * @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.
+     * @returns Promise<{}>
+     */
+    getRecordContent(recordId, opts) {
+        throwIfNotDefined(recordId, 'recordId');
+        const pathParams = {
+            recordId
+        };
+        const queryParams = {
+            attachment: opts?.attachment
+        };
+        const headerParams = {
+            'If-Modified-Since': opts?.ifModifiedSince
+        };
+        return this.get({
+            path: '/records/{recordId}/content',
+            pathParams,
+            queryParams,
+            headerParams
+        });
+    }
+    /**
+     * Update record
+     *
+     * Updates the record **recordId**. For example, you can rename a record:
+     * JSON
+     * {
+     *   \"name\":\"My new name\"
+     * }
+     *
+     * You can also set or update one or more properties:
+     * JSON
+     * {
+     *   \"properties\":
+     *     {
+     *        \"cm:title\":\"New title\",
+     *        \"cm:description\":\"New description\"
+     *     }
+     * }
+     *
+     * **Note:** if you want to add or remove aspects, then you must use **GET /records/{recordId}** first to get the complete set of *aspectNames*.
+     * **Note:** Currently there is no optimistic locking for updates, so they are applied in \"last one wins\" order.
+     *
+     * @param recordId The identifier of a record.
+     * @param recordBodyUpdate The record information to update.
+     * @param opts Optional parameters
+     * @returns Promise<RecordEntry>
+     */
+    updateRecord(recordId, recordBodyUpdate, opts) {
+        throwIfNotDefined(recordId, 'recordId');
+        throwIfNotDefined(recordBodyUpdate, 'recordBodyUpdate');
+        const pathParams = {
+            recordId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/records/{recordId}',
+            pathParams,
+            queryParams,
+            bodyParam: recordBodyUpdate,
+            returnType: RecordEntry
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"records.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/gs-core-rest-api/api/records.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 { FilePlanComponentBodyUpdate } from '../model/filePlanComponentBodyUpdate';\nimport { RecordEntry } from '../model/recordEntry';\nimport { RequestBodyFile } from '../model/requestBodyFile';\nimport { BaseApi } from './base.api';\nimport { buildCollectionParam } from '../../../alfrescoApiClient';\nimport { throwIfNotDefined } from '../../../assert';\nimport { RecordsIncludeQuery } from './types';\n\n/**\n * Records service.\n *\n * @module RecordsApi\n */\nexport class RecordsApi extends BaseApi {\n    /**\n     * Complete a record\n     *\n     * @param recordId The identifier of a record.\n     * @param opts Optional parameters\n     * @returns Promise<RecordEntry>\n     */\n    completeRecord(recordId: string, opts?: RecordsIncludeQuery): Promise<RecordEntry> {\n        throwIfNotDefined(recordId, 'recordId');\n\n        const pathParams = {\n            recordId\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: '/records/{recordId}/complete',\n            pathParams,\n            queryParams,\n            returnType: RecordEntry\n        });\n    }\n\n    /**\n     * Delete a record. Deleted file plan components cannot be recovered, they are deleted permanently.\n     *\n     * @param recordId The identifier of a record.\n     * @returns Promise<{}>\n     */\n    deleteRecord(recordId: string): Promise<void> {\n        throwIfNotDefined(recordId, 'recordId');\n\n        const pathParams = {\n            recordId\n        };\n\n        return this.delete({\n            path: '/records/{recordId}',\n            pathParams\n        });\n    }\n\n    /**\n     * File a record\n     *\n     * You need to specify the target record folder by providing its id **targetParentId**\n     * If the record is already filed, a link to the target record folder is created.\n     * You can use the **include** parameter (include=allowableOperations) to return additional information.\n     *\n     * @param recordId The identifier of a record.\n     * @param nodeBodyFile The target record folder id\n     * @param opts Optional parameters\n     * @returns Promise<RecordEntry>\n     */\n    fileRecord(recordId: string, nodeBodyFile: RequestBodyFile, opts?: RecordsIncludeQuery): Promise<RecordEntry> {\n        throwIfNotDefined(recordId, 'recordId');\n        throwIfNotDefined(nodeBodyFile, 'nodeBodyFile');\n\n        const pathParams = {\n            recordId\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: '/records/{recordId}/file',\n            pathParams,\n            queryParams,\n            bodyParam: nodeBodyFile,\n            returnType: RecordEntry\n        });\n    }\n\n    /**\n     * Get a record\n     *\n     * Mandatory fields and the record's aspects and properties are returned by default.\n     * You can use the **include** parameter (include=allowableOperations) to return additional information.\n     *\n     * @param recordId The identifier of a record.\n     * @param opts Optional parameters\n     * @returns Promise<RecordEntry>\n     */\n    getRecord(recordId: string, opts?: RecordsIncludeQuery): Promise<RecordEntry> {\n        throwIfNotDefined(recordId, 'recordId');\n\n        const pathParams = {\n            recordId\n        };\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/records/{recordId}',\n            pathParams,\n            queryParams,\n            returnType: RecordEntry\n        });\n    }\n\n    /**\n     * Get record content\n     *\n     * @param recordId The identifier of a record.\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     *\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     *\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     * @returns Promise<{}>\n     */\n    getRecordContent(\n        recordId: string,\n        opts?: {\n            attachment?: boolean;\n            ifModifiedSince?: string;\n        }\n    ): Promise<any> {\n        throwIfNotDefined(recordId, 'recordId');\n\n        const pathParams = {\n            recordId\n        };\n\n        const queryParams = {\n            attachment: opts?.attachment\n        };\n\n        const headerParams = {\n            'If-Modified-Since': opts?.ifModifiedSince\n        };\n\n        return this.get({\n            path: '/records/{recordId}/content',\n            pathParams,\n            queryParams,\n            headerParams\n        });\n    }\n\n    /**\n     * Update record\n     *\n     * Updates the record **recordId**. For example, you can rename a record:\n     * JSON\n     * {\n     *   \\\"name\\\":\\\"My new name\\\"\n     * }\n     *\n     * You can also set or update one or more properties:\n     * JSON\n     * {\n     *   \\\"properties\\\":\n     *     {\n     *        \\\"cm:title\\\":\\\"New title\\\",\n     *        \\\"cm:description\\\":\\\"New description\\\"\n     *     }\n     * }\n     *\n     * **Note:** if you want to add or remove aspects, then you must use **GET /records/{recordId}** first to get the complete set of *aspectNames*.\n     * **Note:** Currently there is no optimistic locking for updates, so they are applied in \\\"last one wins\\\" order.\n     *\n     * @param recordId The identifier of a record.\n     * @param recordBodyUpdate The record information to update.\n     * @param opts Optional parameters\n     * @returns Promise<RecordEntry>\n     */\n    updateRecord(recordId: string, recordBodyUpdate: FilePlanComponentBodyUpdate, opts?: RecordsIncludeQuery): Promise<RecordEntry> {\n        throwIfNotDefined(recordId, 'recordId');\n        throwIfNotDefined(recordBodyUpdate, 'recordBodyUpdate');\n\n        const pathParams = {\n            recordId\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: '/records/{recordId}',\n            pathParams,\n            queryParams,\n            bodyParam: recordBodyUpdate,\n            returnType: RecordEntry\n        });\n    }\n}\n"]}

package/esm2020/api/gs-core-rest-api/api/transferContainers.api.mjs

@@ -0,0 +1,110 @@
+/*!
+ * @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 { TransferContainerAssociationPaging } from '../model/transferContainerAssociationPaging';
+import { TransferContainerEntry } from '../model/transferContainerEntry';
+import { BaseApi } from './base.api';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * TransferContainersApi service.
+ */
+export class TransferContainersApi extends BaseApi {
+    /**
+     * Get a transfer container
+     *
+     * Mandatory fields and the transfer container's aspects and properties are returned by default.
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param transferContainerId The identifier of a transfer container. You can also use the -transfers- alias.
+     * @param opts Optional parameters
+     * @returns Promise<TransferContainerEntry>
+     */
+    getTransferContainer(transferContainerId, opts) {
+        throwIfNotDefined(transferContainerId, 'transferContainerId');
+        const pathParams = {
+            transferContainerId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/transfer-containers/{transferContainerId}',
+            pathParams,
+            queryParams,
+            returnType: TransferContainerEntry
+        });
+    }
+    /**
+     * List transfer container's children
+     *
+     * Minimal information for each child is returned by default.
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param transferContainerId The identifier of a transfer container. You can also use the -transfers- alias.
+     * @param opts Optional parameters
+     * @returns Promise<TransferContainerAssociationPaging>
+     */
+    listTransfers(transferContainerId, opts) {
+        throwIfNotDefined(transferContainerId, 'transferContainerId');
+        opts = opts || {};
+        const pathParams = {
+            transferContainerId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            includeSource: opts?.includeSource,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/transfer-containers/{transferContainerId}/transfers',
+            pathParams,
+            queryParams,
+            returnType: TransferContainerAssociationPaging
+        });
+    }
+    /**
+     * Update transfer container
+     *
+     * @param transferContainerId The identifier of a transfer container. You can also use the -transfers- alias.
+     * @param nodeBodyUpdate The node information to update.
+     * @param opts Optional parameters
+     * @returns Promise<TransferContainerEntry>
+     */
+    updateTransferContainer(transferContainerId, nodeBodyUpdate, opts) {
+        throwIfNotDefined(transferContainerId, 'transferContainerId');
+        throwIfNotDefined(nodeBodyUpdate, 'nodeBodyUpdate');
+        opts = opts || {};
+        const pathParams = {
+            transferContainerId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/transfer-containers/{transferContainerId}',
+            pathParams,
+            queryParams,
+            bodyParam: nodeBodyUpdate,
+            returnType: TransferContainerEntry
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transferContainers.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/gs-core-rest-api/api/transferContainers.api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,kCAAkC,EAAE,MAAM,6CAA6C,CAAC;AAEjG,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAGpD;;GAEG;AACH,MAAM,OAAO,qBAAsB,SAAQ,OAAO;IAC9C;;;;;;;;;OASG;IACH,oBAAoB,CAAC,mBAA2B,EAAE,IAA0B;QACxE,iBAAiB,CAAC,mBAAmB,EAAE,qBAAqB,CAAC,CAAC;QAE9D,MAAM,UAAU,GAAG;YACf,mBAAmB;SACtB,CAAC;QAEF,MAAM,WAAW,GAAG;YAChB,OAAO,EAAE,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC;YACnD,MAAM,EAAE,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC;SACpD,CAAC;QAEF,OAAO,IAAI,CAAC,GAAG,CAAC;YACZ,IAAI,EAAE,4CAA4C;YAClD,UAAU;YACV,WAAW;YACX,UAAU,EAAE,sBAAsB;SACrC,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;OASG;IACH,aAAa,CACT,mBAA2B,EAC3B,IAAoE;QAEpE,iBAAiB,CAAC,mBAAmB,EAAE,qBAAqB,CAAC,CAAC;QAC9D,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAElB,MAAM,UAAU,GAAG;YACf,mBAAmB;SACtB,CAAC;QAEF,MAAM,WAAW,GAAG;YAChB,SAAS,EAAE,IAAI,EAAE,SAAS;YAC1B,QAAQ,EAAE,IAAI,EAAE,QAAQ;YACxB,OAAO,EAAE,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC;YACnD,aAAa,EAAE,IAAI,EAAE,aAAa;YAClC,MAAM,EAAE,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC;SACpD,CAAC;QAEF,OAAO,IAAI,CAAC,GAAG,CAAC;YACZ,IAAI,EAAE,sDAAsD;YAC5D,UAAU;YACV,WAAW;YACX,UAAU,EAAE,kCAAkC;SACjD,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;OAOG;IACH,uBAAuB,CACnB,mBAA2B,EAC3B,cAA2C,EAC3C,IAA0B;QAE1B,iBAAiB,CAAC,mBAAmB,EAAE,qBAAqB,CAAC,CAAC;QAC9D,iBAAiB,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;QACpD,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAElB,MAAM,UAAU,GAAG;YACf,mBAAmB;SACtB,CAAC;QAEF,MAAM,WAAW,GAAG;YAChB,OAAO,EAAE,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC;YACnD,MAAM,EAAE,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC;SACpD,CAAC;QAEF,OAAO,IAAI,CAAC,GAAG,CAAC;YACZ,IAAI,EAAE,4CAA4C;YAClD,UAAU;YACV,WAAW;YACX,SAAS,EAAE,cAAc;YACzB,UAAU,EAAE,sBAAsB;SACrC,CAAC,CAAC;IACP,CAAC;CACJ","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 { TransferContainerAssociationPaging } from '../model/transferContainerAssociationPaging';\nimport { TransferContainerBodyUpdate } from '../model/transferContainerBodyUpdate';\nimport { TransferContainerEntry } from '../model/transferContainerEntry';\nimport { BaseApi } from './base.api';\nimport { buildCollectionParam } from '../../../alfrescoApiClient';\nimport { throwIfNotDefined } from '../../../assert';\nimport { RecordsIncludeQuery, RecordsPagingQuery, RecordsSourceQuery } from './types';\n\n/**\n * TransferContainersApi service.\n */\nexport class TransferContainersApi extends BaseApi {\n    /**\n     * Get a transfer container\n     *\n     * Mandatory fields and the transfer container's aspects and properties are returned by default.\n     * You can use the **include** parameter (include=allowableOperations) to return additional information.\n     *\n     * @param transferContainerId The identifier of a transfer container. You can also use the -transfers- alias.\n     * @param opts Optional parameters\n     * @returns Promise<TransferContainerEntry>\n     */\n    getTransferContainer(transferContainerId: string, opts?: RecordsIncludeQuery): Promise<TransferContainerEntry> {\n        throwIfNotDefined(transferContainerId, 'transferContainerId');\n\n        const pathParams = {\n            transferContainerId\n        };\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/transfer-containers/{transferContainerId}',\n            pathParams,\n            queryParams,\n            returnType: TransferContainerEntry\n        });\n    }\n\n    /**\n     * List transfer container's children\n     *\n     * Minimal information for each child is returned by default.\n     * You can use the **include** parameter (include=allowableOperations) to return additional information.\n     *\n     * @param transferContainerId The identifier of a transfer container. You can also use the -transfers- alias.\n     * @param opts Optional parameters\n     * @returns Promise<TransferContainerAssociationPaging>\n     */\n    listTransfers(\n        transferContainerId: string,\n        opts?: RecordsSourceQuery & RecordsIncludeQuery & RecordsPagingQuery\n    ): Promise<TransferContainerAssociationPaging> {\n        throwIfNotDefined(transferContainerId, 'transferContainerId');\n        opts = opts || {};\n\n        const pathParams = {\n            transferContainerId\n        };\n\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            includeSource: opts?.includeSource,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/transfer-containers/{transferContainerId}/transfers',\n            pathParams,\n            queryParams,\n            returnType: TransferContainerAssociationPaging\n        });\n    }\n\n    /**\n     * Update transfer container\n     *\n     * @param transferContainerId The identifier of a transfer container. You can also use the -transfers- alias.\n     * @param nodeBodyUpdate The node information to update.\n     * @param opts Optional parameters\n     * @returns Promise<TransferContainerEntry>\n     */\n    updateTransferContainer(\n        transferContainerId: string,\n        nodeBodyUpdate: TransferContainerBodyUpdate,\n        opts?: RecordsIncludeQuery\n    ): Promise<TransferContainerEntry> {\n        throwIfNotDefined(transferContainerId, 'transferContainerId');\n        throwIfNotDefined(nodeBodyUpdate, 'nodeBodyUpdate');\n        opts = opts || {};\n\n        const pathParams = {\n            transferContainerId\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: '/transfer-containers/{transferContainerId}',\n            pathParams,\n            queryParams,\n            bodyParam: nodeBodyUpdate,\n            returnType: TransferContainerEntry\n        });\n    }\n}\n"]}

package/esm2020/api/gs-core-rest-api/api/transfers.api.mjs

@@ -0,0 +1,84 @@
+/*!
+ * @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 { TransferAssociationPaging } from '../model/transferAssociationPaging';
+import { TransferEntry } from '../model/transferEntry';
+import { BaseApi } from './base.api';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * Transfers service.
+ *
+ * @module TransfersApi
+ */
+export class TransfersApi extends BaseApi {
+    /**
+     * Get a transfer
+     *
+     * Mandatory fields and the transfer's aspects and properties are returned by default.
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param transferId The identifier of a transfer.
+     * @param opts Optional parameters
+     * @returns Promise<TransferEntry>
+     */
+    getTransfer(transferId, opts) {
+        throwIfNotDefined(transferId, 'transferId');
+        const pathParams = {
+            transferId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/transfers/{transferId}',
+            pathParams,
+            queryParams,
+            returnType: TransferEntry
+        });
+    }
+    /**
+     * List transfer's children
+     *
+     * Minimal information for each child is returned by default.
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param transferId The identifier of a transfer.
+     * @param opts Optional parameters
+     * @returns Promise<TransferAssociationPaging>
+     */
+    listTransfersChildren(transferId, opts) {
+        throwIfNotDefined(transferId, 'transferId');
+        const pathParams = {
+            transferId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            includeSource: opts?.includeSource,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/transfers/{transferId}/children',
+            pathParams,
+            queryParams,
+            returnType: TransferAssociationPaging
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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