@alfresco/js-api 7.3.0-1530 → 7.3.0

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

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,151 @@
+/*!
+ * @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 { UnfiledContainerAssociationPaging, UnfiledContainerEntry } from '../model';
+import { BaseApi } from './base.api';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * Unfiled containers service.
+ *
+ * @module UnfiledContainersApi
+ */
+export class UnfiledContainersApi extends BaseApi {
+    /**
+     * Creates a record or an unfiled record folder as a primary child of **unfiledContainerId**.
+     *
+     * @param unfiledContainerId The identifier of an unfiled records container. You can use the **-unfiled-** alias.
+     * @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.
+     * @returns Promise<UnfiledContainerAssociationPaging>
+     */
+    createUnfiledContainerChildren(unfiledContainerId, nodeBodyCreate, opts) {
+        throwIfNotDefined(unfiledContainerId, 'unfiledContainerId');
+        throwIfNotDefined(nodeBodyCreate, 'nodeBodyCreate');
+        const pathParams = {
+            unfiledContainerId
+        };
+        const queryParams = {
+            autoRename: opts?.autoRename,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        const contentTypes = ['application/json', 'multipart/form-data'];
+        return this.post({
+            path: '/unfiled-containers/{unfiledContainerId}/children',
+            pathParams,
+            queryParams,
+            contentTypes,
+            bodyParam: nodeBodyCreate,
+            returnType: UnfiledContainerAssociationPaging
+        });
+    }
+    /**
+     * Get the unfiled records container
+     *
+     * Gets information for unfiled records container **unfiledContainerId**
+     * Mandatory fields and the unfiled records container's aspects and properties are returned by default.
+     *
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param unfiledContainerId The identifier of an unfiled records container. You can use the **-unfiled-** alias.
+     * @param opts Optional parameters
+     * @returns Promise<UnfiledContainerEntry>
+     */
+    getUnfiledContainer(unfiledContainerId, opts) {
+        throwIfNotDefined(unfiledContainerId, 'unfiledContainerId');
+        const pathParams = {
+            unfiledContainerId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/unfiled-containers/{unfiledContainerId}',
+            pathParams,
+            queryParams,
+            returnType: UnfiledContainerEntry
+        });
+    }
+    /**
+     * List unfiled record container's children
+     *
+     * Returns a list of records or unfiled record folders.
+     *
+     * Minimal information for each child is returned by default.
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param unfiledContainerId The identifier of an unfiled records container. You can use the **-unfiled-** alias.
+     * @param opts Optional parameters
+     * @param opts.where Optionally filter the list. Here are some examples:
+     *   - where=(isRecord=true)
+     *   - where=(isUnfiledRecordFolder=false)
+     *   - where=(nodeType='cm:content INCLUDESUBTYPES')
+     * @param opts.includeSource Also include **source** (in addition to **entries**) with folder information on the parent node – the specified parent **unfiledContainerId**
+     * @returns Promise<UnfiledContainerAssociationPaging>
+     */
+    listUnfiledContainerChildren(unfiledContainerId, opts) {
+        throwIfNotDefined(unfiledContainerId, 'unfiledContainerId');
+        const pathParams = {
+            unfiledContainerId
+        };
+        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: '/unfiled-containers/{unfiledContainerId}/children',
+            pathParams,
+            queryParams,
+            returnType: UnfiledContainerAssociationPaging
+        });
+    }
+    /**
+     * Update an unfiled record container
+     *
+     * **Note:** Currently there is no optimistic locking for updates, so they are applied in \"last one wins\" order.
+     *
+     * @param unfiledContainerId The identifier of an unfiled records container. You can use the **-unfiled-** alias.
+     * @param unfiledContainerBodyUpdate The unfiled record container information to update.
+     * @param opts Optional parameters
+     * @returns Promise<UnfiledContainerEntry>
+     */
+    updateUnfiledContainer(unfiledContainerId, unfiledContainerBodyUpdate, opts) {
+        throwIfNotDefined(unfiledContainerId, 'unfiledContainerId');
+        throwIfNotDefined(unfiledContainerBodyUpdate, 'unfiledContainerBodyUpdate');
+        const pathParams = {
+            unfiledContainerId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/unfiled-containers/{unfiledContainerId}',
+            pathParams,
+            queryParams,
+            bodyParam: unfiledContainerBodyUpdate,
+            returnType: UnfiledContainerEntry
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unfiledContainers.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/gs-core-rest-api/api/unfiledContainers.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 { RMNodeBodyCreate, UnfiledContainerAssociationPaging, UnfiledContainerEntry, UnfiledRecordContainerBodyUpdate } from '../model';\nimport { BaseApi } from './base.api';\nimport { buildCollectionParam } from '../../../alfrescoApiClient';\nimport { throwIfNotDefined } from '../../../assert';\nimport { RecordsIncludeQuery, RecordsPagingQuery, RecordsSourceQuery } from './types';\n\n/**\n * Unfiled containers service.\n *\n * @module UnfiledContainersApi\n */\nexport class UnfiledContainersApi extends BaseApi {\n    /**\n     * Creates a record or an unfiled record folder as a primary child of **unfiledContainerId**.\n     *\n     * @param unfiledContainerId The identifier of an unfiled records container. You can use the **-unfiled-** alias.\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     * @returns Promise<UnfiledContainerAssociationPaging>\n     */\n    createUnfiledContainerChildren(\n        unfiledContainerId: string,\n        nodeBodyCreate: RMNodeBodyCreate,\n        opts?: {\n            autoRename?: boolean;\n        } & RecordsIncludeQuery\n    ): Promise<UnfiledContainerAssociationPaging> {\n        throwIfNotDefined(unfiledContainerId, 'unfiledContainerId');\n        throwIfNotDefined(nodeBodyCreate, 'nodeBodyCreate');\n\n        const pathParams = {\n            unfiledContainerId\n        };\n\n        const queryParams = {\n            autoRename: opts?.autoRename,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        const contentTypes = ['application/json', 'multipart/form-data'];\n\n        return this.post({\n            path: '/unfiled-containers/{unfiledContainerId}/children',\n            pathParams,\n            queryParams,\n            contentTypes,\n            bodyParam: nodeBodyCreate,\n            returnType: UnfiledContainerAssociationPaging\n        });\n    }\n\n    /**\n     * Get the unfiled records container\n     *\n     * Gets information for unfiled records container **unfiledContainerId**\n     * Mandatory fields and the unfiled records container's aspects and properties are returned by default.\n     *\n     * You can use the **include** parameter (include=allowableOperations) to return additional information.\n     *\n     * @param unfiledContainerId The identifier of an unfiled records container. You can use the **-unfiled-** alias.\n     * @param opts Optional parameters\n     * @returns Promise<UnfiledContainerEntry>\n     */\n    getUnfiledContainer(unfiledContainerId: string, opts?: RecordsIncludeQuery): Promise<UnfiledContainerEntry> {\n        throwIfNotDefined(unfiledContainerId, 'unfiledContainerId');\n\n        const pathParams = {\n            unfiledContainerId\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: '/unfiled-containers/{unfiledContainerId}',\n            pathParams,\n            queryParams,\n            returnType: UnfiledContainerEntry\n        });\n    }\n\n    /**\n     * List unfiled record container's children\n     *\n     * Returns a list of records or unfiled record folders.\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 unfiledContainerId The identifier of an unfiled records container. You can use the **-unfiled-** alias.\n     * @param opts Optional parameters\n     * @param opts.where Optionally filter the list. Here are some examples:\n     *   - where=(isRecord=true)\n     *   - where=(isUnfiledRecordFolder=false)\n     *   - where=(nodeType='cm:content INCLUDESUBTYPES')\n     * @param opts.includeSource Also include **source** (in addition to **entries**) with folder information on the parent node – the specified parent **unfiledContainerId**\n     * @returns Promise<UnfiledContainerAssociationPaging>\n     */\n    listUnfiledContainerChildren(\n        unfiledContainerId: string,\n        opts?: {\n            where?: string;\n        } & RecordsSourceQuery &\n            RecordsIncludeQuery &\n            RecordsPagingQuery\n    ): Promise<UnfiledContainerAssociationPaging> {\n        throwIfNotDefined(unfiledContainerId, 'unfiledContainerId');\n\n        const pathParams = {\n            unfiledContainerId\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: '/unfiled-containers/{unfiledContainerId}/children',\n            pathParams,\n            queryParams,\n            returnType: UnfiledContainerAssociationPaging\n        });\n    }\n\n    /**\n     * Update an unfiled record container\n     *\n     * **Note:** Currently there is no optimistic locking for updates, so they are applied in \\\"last one wins\\\" order.\n     *\n     * @param unfiledContainerId The identifier of an unfiled records container. You can use the **-unfiled-** alias.\n     * @param unfiledContainerBodyUpdate The unfiled record container information to update.\n     * @param opts Optional parameters\n     * @returns Promise<UnfiledContainerEntry>\n     */\n    updateUnfiledContainer(\n        unfiledContainerId: string,\n        unfiledContainerBodyUpdate: UnfiledRecordContainerBodyUpdate,\n        opts?: RecordsIncludeQuery\n    ): Promise<UnfiledContainerEntry> {\n        throwIfNotDefined(unfiledContainerId, 'unfiledContainerId');\n        throwIfNotDefined(unfiledContainerBodyUpdate, 'unfiledContainerBodyUpdate');\n\n        const pathParams = {\n            unfiledContainerId\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: '/unfiled-containers/{unfiledContainerId}',\n            pathParams,\n            queryParams,\n            bodyParam: unfiledContainerBodyUpdate,\n            returnType: UnfiledContainerEntry\n        });\n    }\n}\n"]}

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

@@ -0,0 +1,167 @@
+/*!
+ * @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 { UnfiledRecordFolderAssociationPaging } from '../model/unfiledRecordFolderAssociationPaging';
+import { UnfiledRecordFolderEntry } from '../model/unfiledRecordFolderEntry';
+import { BaseApi } from './base.api';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * UnfiledRecordFoldersApi service.
+ *
+ * @module UnfiledRecordFoldersApi
+ */
+export class UnfiledRecordFoldersApi extends BaseApi {
+    /**
+     * Create a record or an unfiled record folder
+     *
+     * @param unfiledRecordFolderId The identifier of an unfiled record folder.
+     * @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.
+     * @returns Promise<UnfiledRecordFolderAssociationPaging>
+     */
+    createUnfiledRecordFolderChildren(unfiledRecordFolderId, nodeBodyCreate, opts) {
+        throwIfNotDefined(unfiledRecordFolderId, 'unfiledRecordFolderId');
+        throwIfNotDefined(nodeBodyCreate, 'nodeBodyCreate');
+        const pathParams = {
+            unfiledRecordFolderId
+        };
+        const queryParams = {
+            autoRename: opts?.autoRename,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/unfiled-record-folders/{unfiledRecordFolderId}/children',
+            pathParams,
+            queryParams,
+            bodyParam: nodeBodyCreate,
+            contentTypes: ['application/json', 'multipart/form-data'],
+            returnType: UnfiledRecordFolderAssociationPaging
+        });
+    }
+    /**
+     * Delete an unfiled record folder. Deleted file plan components cannot be recovered, they are deleted permanently.
+     *
+     * @param unfiledRecordFolderId The identifier of an unfiled record folder.
+     * @returns Promise<{}>
+     */
+    deleteUnfiledRecordFolder(unfiledRecordFolderId) {
+        throwIfNotDefined(unfiledRecordFolderId, 'unfiledRecordFolderId');
+        const pathParams = {
+            unfiledRecordFolderId
+        };
+        return this.delete({
+            path: '/unfiled-record-folders/{unfiledRecordFolderId}',
+            pathParams
+        });
+    }
+    /**
+     * Get the unfiled record folder
+     *
+     * Mandatory fields and the unfiled record folder's aspects and properties are returned by default.
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param unfiledRecordFolderId The identifier of an unfiled record folder.
+     * @param opts Optional parameters
+     * @param opts.relativePath Return information on children in the unfiled records container resolved by this path. The path is relative to **unfiledRecordFolderId**.
+     * @returns Promise<UnfiledRecordFolderEntry>
+     */
+    getUnfiledRecordFolder(unfiledRecordFolderId, opts) {
+        throwIfNotDefined(unfiledRecordFolderId, 'unfiledRecordFolderId');
+        const pathParams = {
+            unfiledRecordFolderId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            relativePath: opts?.relativePath,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/unfiled-record-folders/{unfiledRecordFolderId}',
+            pathParams,
+            queryParams,
+            returnType: UnfiledRecordFolderEntry
+        });
+    }
+    /**
+     * List unfiled record folder's children
+     *
+     * Minimal information for each child is returned by default.
+     * You can use the **include** parameter (include=allowableOperations) to return additional information.
+     *
+     * @param unfiledRecordFolderId The identifier of an unfiled record folder.
+     * @param opts Optional parameters
+     * @param opts.where Optionally filter the list. Here are some examples:
+     *  - where=(isRecord=true)
+     *  - where=(isUnfiledRecordFolder=false)
+     *  - where=(nodeType='cm:content INCLUDESUBTYPES')
+     * @param opts.relativePath Return information on children in the unfiled records container resolved by this path. The path is relative to **unfiledRecordFolderId**.
+     * @returns Promise<UnfiledRecordFolderAssociationPaging>
+     */
+    listUnfiledRecordFolderChildren(unfiledRecordFolderId, opts) {
+        throwIfNotDefined(unfiledRecordFolderId, 'unfiledRecordFolderId');
+        opts = opts || {};
+        const pathParams = {
+            unfiledRecordFolderId
+        };
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            where: opts?.where,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            relativePath: opts?.relativePath,
+            includeSource: opts?.includeSource,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/unfiled-record-folders/{unfiledRecordFolderId}/children',
+            pathParams,
+            queryParams,
+            returnType: UnfiledRecordFolderAssociationPaging
+        });
+    }
+    /**
+     * Updates unfiled record folder **unfiledRecordFolderId**.
+     * For example, you can rename a record folder:
+     *
+     * @param unfiledRecordFolderId The identifier of an unfiled record folder.
+     * @param unfiledRecordFolderBodyUpdate The record folder information to update.
+     * @param opts Optional parameters
+     * @returns Promise<UnfiledRecordFolderEntry>
+     */
+    updateUnfiledRecordFolder(unfiledRecordFolderId, unfiledRecordFolderBodyUpdate, opts) {
+        throwIfNotDefined(unfiledRecordFolderId, 'unfiledRecordFolderId');
+        throwIfNotDefined(unfiledRecordFolderBodyUpdate, 'unfiledRecordFolderBodyUpdate');
+        const pathParams = {
+            unfiledRecordFolderId
+        };
+        const queryParams = {
+            include: buildCollectionParam(opts?.include, 'csv'),
+            includeSource: opts?.includeSource,
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/unfiled-record-folders/{unfiledRecordFolderId}',
+            pathParams,
+            queryParams,
+            bodyParam: unfiledRecordFolderBodyUpdate,
+            returnType: UnfiledRecordFolderEntry
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unfiledRecordFolders.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/gs-core-rest-api/api/unfiledRecordFolders.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 { RMNodeBodyCreateWithRelativePath } from '../model/rMNodeBodyCreateWithRelativePath';\nimport { UnfiledRecordFolderAssociationPaging } from '../model/unfiledRecordFolderAssociationPaging';\nimport { UnfiledRecordFolderBodyUpdate } from '../model/unfiledRecordFolderBodyUpdate';\nimport { UnfiledRecordFolderEntry } from '../model/unfiledRecordFolderEntry';\nimport { BaseApi } from './base.api';\nimport { buildCollectionParam } from '../../../alfrescoApiClient';\nimport { throwIfNotDefined } from '../../../assert';\nimport { RecordsIncludeQuery, RecordsPagingQuery, RecordsSourceQuery } from './types';\n\n/**\n * UnfiledRecordFoldersApi service.\n *\n * @module UnfiledRecordFoldersApi\n */\nexport class UnfiledRecordFoldersApi extends BaseApi {\n    /**\n     * Create a record or an unfiled record folder\n     *\n     * @param unfiledRecordFolderId The identifier of an unfiled record folder.\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     * @returns Promise<UnfiledRecordFolderAssociationPaging>\n     */\n    createUnfiledRecordFolderChildren(\n        unfiledRecordFolderId: string,\n        nodeBodyCreate: RMNodeBodyCreateWithRelativePath,\n        opts?: {\n            autoRename?: boolean;\n        } & RecordsIncludeQuery\n    ): Promise<UnfiledRecordFolderAssociationPaging> {\n        throwIfNotDefined(unfiledRecordFolderId, 'unfiledRecordFolderId');\n        throwIfNotDefined(nodeBodyCreate, 'nodeBodyCreate');\n\n        const pathParams = {\n            unfiledRecordFolderId\n        };\n\n        const queryParams = {\n            autoRename: opts?.autoRename,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/unfiled-record-folders/{unfiledRecordFolderId}/children',\n            pathParams,\n            queryParams,\n            bodyParam: nodeBodyCreate,\n            contentTypes: ['application/json', 'multipart/form-data'],\n            returnType: UnfiledRecordFolderAssociationPaging\n        });\n    }\n\n    /**\n     * Delete an unfiled record folder. Deleted file plan components cannot be recovered, they are deleted permanently.\n     *\n     * @param unfiledRecordFolderId The identifier of an unfiled record folder.\n     * @returns Promise<{}>\n     */\n    deleteUnfiledRecordFolder(unfiledRecordFolderId: string): Promise<void> {\n        throwIfNotDefined(unfiledRecordFolderId, 'unfiledRecordFolderId');\n\n        const pathParams = {\n            unfiledRecordFolderId\n        };\n\n        return this.delete({\n            path: '/unfiled-record-folders/{unfiledRecordFolderId}',\n            pathParams\n        });\n    }\n\n    /**\n     * Get the unfiled record folder\n     *\n     * Mandatory fields and the unfiled 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 unfiledRecordFolderId The identifier of an unfiled record folder.\n     * @param opts Optional parameters\n     * @param opts.relativePath Return information on children in the unfiled records container resolved by this path. The path is relative to **unfiledRecordFolderId**.\n     * @returns Promise<UnfiledRecordFolderEntry>\n     */\n    getUnfiledRecordFolder(\n        unfiledRecordFolderId: string,\n        opts?: {\n            relativePath?: string;\n        } & RecordsIncludeQuery\n    ): Promise<UnfiledRecordFolderEntry> {\n        throwIfNotDefined(unfiledRecordFolderId, 'unfiledRecordFolderId');\n\n        const pathParams = {\n            unfiledRecordFolderId\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: '/unfiled-record-folders/{unfiledRecordFolderId}',\n            pathParams,\n            queryParams,\n            returnType: UnfiledRecordFolderEntry\n        });\n    }\n\n    /**\n     * List unfiled record folder'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 unfiledRecordFolderId The identifier of an unfiled record folder.\n     * @param opts Optional parameters\n     * @param opts.where Optionally filter the list. Here are some examples:\n     *  - where=(isRecord=true)\n     *  - where=(isUnfiledRecordFolder=false)\n     *  - where=(nodeType='cm:content INCLUDESUBTYPES')\n     * @param opts.relativePath Return information on children in the unfiled records container resolved by this path. The path is relative to **unfiledRecordFolderId**.\n     * @returns Promise<UnfiledRecordFolderAssociationPaging>\n     */\n    listUnfiledRecordFolderChildren(\n        unfiledRecordFolderId: string,\n        opts?: {\n            where?: string;\n            relativePath?: string[];\n        } & RecordsIncludeQuery &\n            RecordsPagingQuery &\n            RecordsSourceQuery\n    ): Promise<UnfiledRecordFolderAssociationPaging> {\n        throwIfNotDefined(unfiledRecordFolderId, 'unfiledRecordFolderId');\n        opts = opts || {};\n\n        const pathParams = {\n            unfiledRecordFolderId\n        };\n\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\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: '/unfiled-record-folders/{unfiledRecordFolderId}/children',\n            pathParams,\n            queryParams,\n            returnType: UnfiledRecordFolderAssociationPaging\n        });\n    }\n\n    /**\n     * Updates unfiled record folder **unfiledRecordFolderId**.\n     * For example, you can rename a record folder:\n     *\n     * @param unfiledRecordFolderId The identifier of an unfiled record folder.\n     * @param unfiledRecordFolderBodyUpdate The record folder information to update.\n     * @param opts Optional parameters\n     * @returns Promise<UnfiledRecordFolderEntry>\n     */\n    updateUnfiledRecordFolder(\n        unfiledRecordFolderId: string,\n        unfiledRecordFolderBodyUpdate: UnfiledRecordFolderBodyUpdate,\n        opts?: RecordsIncludeQuery & RecordsSourceQuery\n    ): Promise<UnfiledRecordFolderEntry> {\n        throwIfNotDefined(unfiledRecordFolderId, 'unfiledRecordFolderId');\n        throwIfNotDefined(unfiledRecordFolderBodyUpdate, 'unfiledRecordFolderBodyUpdate');\n\n        const pathParams = {\n            unfiledRecordFolderId\n        };\n\n        const queryParams = {\n            include: buildCollectionParam(opts?.include, 'csv'),\n            includeSource: opts?.includeSource,\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.put({\n            path: '/unfiled-record-folders/{unfiledRecordFolderId}',\n            pathParams,\n            queryParams,\n            bodyParam: unfiledRecordFolderBodyUpdate,\n            returnType: UnfiledRecordFolderEntry\n        });\n    }\n}\n"]}

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

@@ -0,0 +1,19 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './api';
+export * from './model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvanMtYXBpL3NyYy9hcGkvZ3MtY29yZS1yZXN0LWFwaS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjMgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbCc7XG4iXX0=

package/esm2020/api/gs-core-rest-api/model/filePlan.mjs

@@ -0,0 +1,31 @@
+/*!
+ * @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 { DateAlfresco } from '../../content-custom-api';
+import { PathInfo, UserInfo } from '../../content-rest-api';
+export class FilePlan {
+    constructor(input) {
+        if (input) {
+            Object.assign(this, input);
+            this.modifiedAt = input.modifiedAt ? DateAlfresco.parseDate(input.modifiedAt) : undefined;
+            this.modifiedByUser = input.modifiedByUser ? new UserInfo(input.modifiedByUser) : undefined;
+            this.createdAt = input.createdAt ? DateAlfresco.parseDate(input.createdAt) : undefined;
+            this.createdByUser = input.createdByUser ? new UserInfo(input.createdByUser) : undefined;
+            this.path = input.path ? new PathInfo(input.path) : undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/gs-core-rest-api/model/filePlanBodyUpdate.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZVBsYW5Cb2R5VXBkYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2pzLWFwaS9zcmMvYXBpL2dzLWNvcmUtcmVzdC1hcGkvbW9kZWwvZmlsZVBsYW5Cb2R5VXBkYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjMgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBGaWxlUGxhbkJvZHlVcGRhdGUge1xuICAgIHByb3BlcnRpZXM/OiB7IFtrZXk6IHN0cmluZ106IHN0cmluZyB9O1xufVxuIl19

package/esm2020/api/gs-core-rest-api/model/filePlanComponentBodyUpdate.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZVBsYW5Db21wb25lbnRCb2R5VXBkYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2pzLWFwaS9zcmMvYXBpL2dzLWNvcmUtcmVzdC1hcGkvbW9kZWwvZmlsZVBsYW5Db21wb25lbnRCb2R5VXBkYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjMgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBGaWxlUGxhbkNvbXBvbmVudEJvZHlVcGRhdGUge1xuICAgIC8qKlxuICAgICAqIFRoZSBuYW1lIG11c3Qgbm90IGNvbnRhaW4gc3BhY2VzIG9yIHRoZSBmb2xsb3dpbmcgc3BlY2lhbCBjaGFyYWN0ZXJzOiAqIFxcXCIgPCA+IFxcXFwgLyA/IDogYW5kIHwuXG4gICAgICogVGhlIGNoYXJhY3RlciAuIG11c3Qgbm90IGJlIHVzZWQgYXQgdGhlIGVuZCBvZiB0aGUgbmFtZS5cbiAgICAgKi9cbiAgICBuYW1lPzogc3RyaW5nO1xuICAgIGFzcGVjdE5hbWVzPzogc3RyaW5nW107XG4gICAgcHJvcGVydGllcz86IHsgW2tleTogc3RyaW5nXTogc3RyaW5nIH07XG59XG4iXX0=

package/esm2020/api/gs-core-rest-api/model/filePlanEntry.mjs

@@ -0,0 +1,26 @@
+/*!
+ * @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 { FilePlan } from './filePlan';
+export class FilePlanEntry {
+    constructor(input) {
+        if (input) {
+            Object.assign(this, input);
+            this.entry = input.entry ? new FilePlan(input.entry) : undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/gs-core-rest-api/model/index.mjs

@@ -0,0 +1,76 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './filePlan';
+export * from './filePlanBodyUpdate';
+export * from './filePlanComponentBodyUpdate';
+export * from './filePlanEntry';
+export * from './rMNodeBodyCreate';
+export * from './rMNodeBodyCreateWithRelativePath';
+export * from './rMSite';
+export * from './rMSiteBodyCreate';
+export * from './rMSiteBodyUpdate';
+export * from './rMSiteEntry';
+export * from './record';
+export * from './recordCategory';
+export * from './recordCategoryChild';
+export * from './recordCategoryChildEntry';
+export * from './recordCategoryChildPaging';
+export * from './recordCategoryChildPagingList';
+export * from './recordCategoryEntry';
+export * from './recordCategoryPaging';
+export * from './recordCategoryPagingList';
+export * from './recordEntry';
+export * from './recordFolder';
+export * from './recordFolderAssociationPaging';
+export * from './recordFolderAssociationPagingList';
+export * from './recordFolderChildAssociationEntry';
+export * from './recordFolderEntry';
+export * from './requestBodyFile';
+export * from './rootCategoryBodyCreate';
+export * from './transfer';
+export * from './transferAssociationPaging';
+export * from './transferAssociationPagingList';
+export * from './transferChild';
+export * from './transferChildAssociationEntry';
+export * from './transferContainer';
+export * from './transferContainerAssociationPaging';
+export * from './transferContainerAssociationPagingList';
+export * from './transferContainerBodyUpdate';
+export * from './transferContainerChild';
+export * from './transferContainerChildAssociationEntry';
+export * from './transferContainerEntry';
+export * from './transferEntry';
+export * from './unfiledContainer';
+export * from './unfiledContainerAssociationPaging';
+export * from './unfiledContainerAssociationPagingList';
+export * from './unfiledContainerChild';
+export * from './unfiledContainerChildAssociationEntry';
+export * from './unfiledContainerEntry';
+export * from './unfiledRecordContainerBodyUpdate';
+export * from './unfiledRecordFolder';
+export * from './unfiledRecordFolderAssociationPaging';
+export * from './unfiledRecordFolderAssociationPagingList';
+export * from './unfiledRecordFolderBodyUpdate';
+export * from './unfiledRecordFolderChild';
+export * from './unfiledRecordFolderChildAssociationEntry';
+export * from './unfiledRecordFolderEntry';
+export * from './recordFolderChildAssociation';
+export * from './transferChildAssociation';
+export * from './transferContainerChildAssociation';
+export * from './unfiledContainerChildAssociation';
+export * from './unfiledRecordFolderChildAssociation';
+//# sourceMappingURL=data:application/json;base64,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