@alfresco/js-api 7.3.0-1530 → 7.3.0

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

@@ -0,0 +1,294 @@
+/*!
+ * @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 { PersonEntry, PersonPaging } from '../model';
+import { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+/**
+ * People service.
+ */
+export class PeopleApi extends BaseApi {
+    /**
+     * Create person
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     * **Note:** setting properties of type d:content and d:category are not supported.
+     *
+     * @param personBodyCreate The person details.
+     * @param opts Optional parameters
+     * @returns Promise<PersonEntry>
+     */
+    createPerson(personBodyCreate, opts) {
+        throwIfNotDefined(personBodyCreate, 'personBodyCreate');
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.post({
+            path: '/people',
+            queryParams,
+            bodyParam: personBodyCreate,
+            returnType: PersonEntry
+        });
+    }
+    /**
+     * Delete avatar image
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.2 and newer versions.
+     *
+     * Deletes the avatar image related to person **personId**.
+     * You must be the person or have admin rights to update a person's avatar.
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param personId The identifier of a person.
+     * @returns Promise<{}>
+     */
+    deleteAvatarImage(personId) {
+        throwIfNotDefined(personId, 'personId');
+        const pathParams = {
+            personId
+        };
+        return this.delete({
+            path: '/people/{personId}/avatar',
+            pathParams
+        });
+    }
+    /**
+     * Get avatar image
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.2 and newer versions.
+     *
+     * Gets the avatar image related to the person **personId**. If the person has no related avatar then
+     * the **placeholder** query parameter can be optionally used to request a placeholder image to be returned.
+     *
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param personId The identifier of a person.
+     * @param opts Optional parameters
+     * @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.placeholder If **true** and there is no avatar for this **personId**
+     * then the placeholder image is returned, rather than a 404 response. (default to true)
+     * @returns Promise<Blob>
+     */
+    getAvatarImage(personId, opts) {
+        throwIfNotDefined(personId, 'personId');
+        const pathParams = {
+            personId
+        };
+        const queryParams = {
+            attachment: opts?.attachment,
+            placeholder: opts?.placeholder
+        };
+        const headerParams = {
+            'If-Modified-Since': opts?.ifModifiedSince
+        };
+        const accepts = ['application/octet-stream'];
+        return this.get({
+            path: '/people/{personId}/avatar',
+            pathParams,
+            queryParams,
+            headerParams,
+            accepts,
+            returnType: 'blob'
+        });
+    }
+    /**
+     * Get a person
+     *
+     * You can use the `-me-` string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param personId The identifier of a person.
+     * @param opts Optional parameters
+     * @returns Promise<PersonEntry>
+     */
+    getPerson(personId, opts) {
+        throwIfNotDefined(personId, 'personId');
+        const pathParams = {
+            personId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/people/{personId}',
+            pathParams,
+            queryParams,
+            returnType: PersonEntry
+        });
+    }
+    /**
+     * List people
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * List people.
+     *
+     * You can use the **include** parameter to return any additional information.
+     *
+     * The default sort order for the returned list is for people to be sorted by ascending id.
+     * You can override the default by using the **orderBy** parameter.
+     *
+     * You can use any of the following fields to order the results:
+     * - id
+     * - firstName
+     * - lastName
+     *
+     * @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.
+     * @returns Promise<PersonPaging>
+     */
+    listPeople(opts) {
+        const queryParams = {
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),
+            include: buildCollectionParam(opts?.include, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/people',
+            queryParams,
+            returnType: PersonPaging
+        });
+    }
+    /**
+     * Request password reset
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.
+     * **Note:** No authentication is required to call this endpoint.
+     *
+     * @param personId The identifier of a person.
+     * @param clientBody The client name to send email with app-specific url.
+     * @returns Promise<{}>
+     */
+    requestPasswordReset(personId, clientBody) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(clientBody, 'clientBody');
+        const pathParams = {
+            personId
+        };
+        return this.post({
+            path: '/people/{personId}/request-password-reset',
+            pathParams,
+            bodyParam: clientBody
+        });
+    }
+    /**
+     * Reset password
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.
+     * **Note:** No authentication is required to call this endpoint.
+     *
+     * @param personId The identifier of a person.
+     * @param passwordResetBody The reset password details
+     * @returns Promise<{}>
+     */
+    resetPassword(personId, passwordResetBody) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(passwordResetBody, 'passwordResetBody');
+        const pathParams = {
+            personId
+        };
+        return this.post({
+            path: '/people/{personId}/reset-password',
+            pathParams,
+            bodyParam: passwordResetBody
+        });
+    }
+    /**
+     * Update avatar image
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2.2 and newer versions.
+     *
+     * Updates the avatar image related to the person **personId**.
+     *
+     * The request body should be the binary stream for the avatar image. The content type of the file
+     * should be an image file. This will be used to generate an \"avatar\" thumbnail rendition.
+     *
+     * You must be the person or have admin rights to update a person's avatar.
+     *
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param personId The identifier of a person.
+     * @param contentBodyUpdate The binary content
+     * @returns Promise<{}>
+     */
+    updateAvatarImage(personId, contentBodyUpdate) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(contentBodyUpdate, 'contentBodyUpdate');
+        const pathParams = {
+            personId
+        };
+        const contentTypes = ['application/octet-stream'];
+        return this.put({
+            path: '/people/{personId}/avatar',
+            pathParams,
+            bodyParam: contentBodyUpdate,
+            contentTypes
+        });
+    }
+    /**
+     * Update person
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * You can use the `-me-` string in place of <personId> to specify the currently authenticated user.
+     * If applicable, the given person's login access can also be optionally disabled or re-enabled.
+     * You must have admin rights to update a person — unless updating your own details.
+     * If you are changing your password, as a non-admin user, then the existing password must also
+     * be supplied (using the oldPassword field in addition to the new password value).
+     *
+     * Admin users cannot be disabled by setting enabled to false.
+     * Non-admin users may not disable themselves.
+     * **Note:** setting properties of type d:content and d:category are not supported.
+     *
+     * @param personId The identifier of a person.
+     * @param personBodyUpdate The person details.
+     * @param opts Optional parameters
+     * @returns Promise<PersonEntry>
+     */
+    updatePerson(personId, personBodyUpdate, opts) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(personBodyUpdate, 'personBodyUpdate');
+        const pathParams = {
+            personId
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.put({
+            path: '/people/{personId}',
+            pathParams,
+            queryParams,
+            bodyParam: personBodyUpdate,
+            returnType: PersonEntry
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"people.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/content-rest-api/api/people.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 { ClientBody, PasswordResetBody, PersonBodyCreate, PersonBodyUpdate, PersonEntry, PersonPaging } from '../model';\nimport { BaseApi } from './base.api';\nimport { throwIfNotDefined } from '../../../assert';\nimport { buildCollectionParam } from '../../../alfrescoApiClient';\nimport { ContentFieldsQuery, ContentIncludeQuery, ContentPagingQuery } from './types';\n\n/**\n * People service.\n */\nexport class PeopleApi extends BaseApi {\n    /**\n     * Create person\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     * **Note:** setting properties of type d:content and d:category are not supported.\n     *\n     * @param personBodyCreate The person details.\n     * @param opts Optional parameters\n     * @returns Promise<PersonEntry>\n     */\n    createPerson(personBodyCreate: PersonBodyCreate, opts?: ContentFieldsQuery): Promise<PersonEntry> {\n        throwIfNotDefined(personBodyCreate, 'personBodyCreate');\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.post({\n            path: '/people',\n            queryParams,\n            bodyParam: personBodyCreate,\n            returnType: PersonEntry\n        });\n    }\n\n    /**\n     * Delete avatar image\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.2 and newer versions.\n     *\n     * Deletes the avatar image related to person **personId**.\n     * You must be the person or have admin rights to update a person's avatar.\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param personId The identifier of a person.\n     * @returns Promise<{}>\n     */\n    deleteAvatarImage(personId: string): Promise<void> {\n        throwIfNotDefined(personId, 'personId');\n\n        const pathParams = {\n            personId\n        };\n\n        return this.delete({\n            path: '/people/{personId}/avatar',\n            pathParams\n        });\n    }\n\n    /**\n     * Get avatar image\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.2 and newer versions.\n     *\n     * Gets the avatar image related to the person **personId**. If the person has no related avatar then\n     * the **placeholder** query parameter can be optionally used to request a placeholder image to be returned.\n     *\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param personId The identifier of a person.\n     * @param opts Optional parameters\n     * @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.placeholder If **true** and there is no avatar for this **personId**\n     * then the placeholder image is returned, rather than a 404 response. (default to true)\n     * @returns Promise<Blob>\n     */\n    getAvatarImage(personId: string, opts?: { attachment?: boolean; placeholder?: boolean; ifModifiedSince?: string }): Promise<Blob> {\n        throwIfNotDefined(personId, 'personId');\n\n        const pathParams = {\n            personId\n        };\n\n        const queryParams = {\n            attachment: opts?.attachment,\n            placeholder: opts?.placeholder\n        };\n\n        const headerParams = {\n            'If-Modified-Since': opts?.ifModifiedSince\n        };\n\n        const accepts = ['application/octet-stream'];\n\n        return this.get({\n            path: '/people/{personId}/avatar',\n            pathParams,\n            queryParams,\n            headerParams,\n            accepts,\n            returnType: 'blob'\n        });\n    }\n\n    /**\n     * Get a person\n     *\n     * You can use the `-me-` string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param personId The identifier of a person.\n     * @param opts Optional parameters\n     * @returns Promise<PersonEntry>\n     */\n    getPerson(personId: string, opts?: ContentFieldsQuery): Promise<PersonEntry> {\n        throwIfNotDefined(personId, 'personId');\n\n        const pathParams = {\n            personId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/people/{personId}',\n            pathParams,\n            queryParams,\n            returnType: PersonEntry\n        });\n    }\n\n    /**\n     * List people\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * List people.\n     *\n     * You can use the **include** parameter to return any additional information.\n     *\n     * The default sort order for the returned list is for people to be sorted by ascending id.\n     * You can override the default by using the **orderBy** parameter.\n     *\n     * You can use any of the following fields to order the results:\n     * - id\n     * - firstName\n     * - lastName\n     *\n     * @param opts Optional parameters\n     * @param opts.orderBy A string to control the order of the entities returned in a list. You can use the **orderBy** parameter to\n     * sort the list by one or more fields.\n     *\n     * Each field has a default sort order, which is normally ascending order. Read the API method implementation notes\n     * above to check if any fields used in this method have a descending default search order.\n     *\n     * To sort the entities in a specific order, you can use the **ASC** and **DESC** keywords for any field.\n     * @returns Promise<PersonPaging>\n     */\n    listPeople(\n        opts?: {\n            orderBy?: string[];\n        } & ContentPagingQuery &\n            ContentIncludeQuery &\n            ContentFieldsQuery\n    ): Promise<PersonPaging> {\n        const queryParams = {\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),\n            include: buildCollectionParam(opts?.include, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/people',\n            queryParams,\n            returnType: PersonPaging\n        });\n    }\n\n    /**\n     * Request password reset\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.\n     * **Note:** No authentication is required to call this endpoint.\n     *\n     * @param personId The identifier of a person.\n     * @param clientBody The client name to send email with app-specific url.\n     * @returns Promise<{}>\n     */\n    requestPasswordReset(personId: string, clientBody: ClientBody): Promise<any> {\n        throwIfNotDefined(personId, 'personId');\n        throwIfNotDefined(clientBody, 'clientBody');\n\n        const pathParams = {\n            personId\n        };\n\n        return this.post({\n            path: '/people/{personId}/request-password-reset',\n            pathParams,\n            bodyParam: clientBody\n        });\n    }\n\n    /**\n     * Reset password\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.1 and newer versions.\n     * **Note:** No authentication is required to call this endpoint.\n     *\n     * @param personId The identifier of a person.\n     * @param passwordResetBody The reset password details\n     * @returns Promise<{}>\n     */\n    resetPassword(personId: string, passwordResetBody: PasswordResetBody): Promise<any> {\n        throwIfNotDefined(personId, 'personId');\n        throwIfNotDefined(passwordResetBody, 'passwordResetBody');\n\n        const pathParams = {\n            personId\n        };\n\n        return this.post({\n            path: '/people/{personId}/reset-password',\n            pathParams,\n            bodyParam: passwordResetBody\n        });\n    }\n\n    /**\n     * Update avatar image\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2.2 and newer versions.\n     *\n     * Updates the avatar image related to the person **personId**.\n     *\n     * The request body should be the binary stream for the avatar image. The content type of the file\n     * should be an image file. This will be used to generate an \\\"avatar\\\" thumbnail rendition.\n     *\n     * You must be the person or have admin rights to update a person's avatar.\n     *\n     * You can use the -me- string in place of <personId> to specify the currently authenticated user.\n     *\n     * @param personId The identifier of a person.\n     * @param contentBodyUpdate The binary content\n     * @returns Promise<{}>\n     */\n    updateAvatarImage(personId: string, contentBodyUpdate: string): Promise<any> {\n        throwIfNotDefined(personId, 'personId');\n        throwIfNotDefined(contentBodyUpdate, 'contentBodyUpdate');\n\n        const pathParams = {\n            personId\n        };\n\n        const contentTypes = ['application/octet-stream'];\n\n        return this.put({\n            path: '/people/{personId}/avatar',\n            pathParams,\n            bodyParam: contentBodyUpdate,\n            contentTypes\n        });\n    }\n\n    /**\n     * Update person\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * You can use the `-me-` string in place of <personId> to specify the currently authenticated user.\n     * If applicable, the given person's login access can also be optionally disabled or re-enabled.\n     * You must have admin rights to update a person — unless updating your own details.\n     * If you are changing your password, as a non-admin user, then the existing password must also\n     * be supplied (using the oldPassword field in addition to the new password value).\n     *\n     * Admin users cannot be disabled by setting enabled to false.\n     * Non-admin users may not disable themselves.\n     * **Note:** setting properties of type d:content and d:category are not supported.\n     *\n     * @param personId The identifier of a person.\n     * @param personBodyUpdate The person details.\n     * @param opts Optional parameters\n     * @returns Promise<PersonEntry>\n     */\n    updatePerson(personId: string, personBodyUpdate: PersonBodyUpdate, opts?: ContentFieldsQuery): Promise<PersonEntry> {\n        throwIfNotDefined(personId, 'personId');\n        throwIfNotDefined(personBodyUpdate, 'personBodyUpdate');\n\n        const pathParams = {\n            personId\n        };\n\n        const queryParams = {\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.put({\n            path: '/people/{personId}',\n            pathParams,\n            queryParams,\n            bodyParam: personBodyUpdate,\n            returnType: PersonEntry\n        });\n    }\n}\n"]}

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

@@ -0,0 +1,79 @@
+/*!
+ * @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 { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+/**
+ * Preferences service.
+ */
+export class PreferencesApi extends BaseApi {
+    /**
+     * Get a preference
+     *
+     * Gets a specific preference for person **personId**.
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     *
+     * @param personId The identifier of a person.
+     * @param preferenceName The name of the preference.
+     * @param opts Optional parameters
+     * @returns Promise<PreferenceEntry>
+     */
+    getPreference(personId, preferenceName, opts) {
+        throwIfNotDefined(personId, 'personId');
+        throwIfNotDefined(preferenceName, 'preferenceName');
+        const pathParams = {
+            personId,
+            preferenceName
+        };
+        const queryParams = {
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/people/{personId}/preferences/{preferenceName}',
+            pathParams,
+            queryParams
+        });
+    }
+    /**
+     * List preferences
+     *
+     * You can use the -me- string in place of <personId> to specify the currently authenticated user.
+     * Note that each preference consists of an **id** and a **value**.
+     *
+     * The **value** can be of any JSON type.
+     *
+     * @param personId The identifier of a person.
+     * @param opts Optional parameters
+     * @returns Promise<PreferencePaging>
+     */
+    listPreferences(personId, opts) {
+        throwIfNotDefined(personId, 'personId');
+        const pathParams = {
+            personId
+        };
+        const queryParams = {
+            ...(opts || {}),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/people/{personId}/preferences',
+            pathParams,
+            queryParams
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,49 @@
+/*!
+ * @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 { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * Probes service.
+ */
+export class ProbesApi extends BaseApi {
+    /**
+     * Check readiness and liveness of the repository
+     *
+     * **Note:** this endpoint is available in Alfresco 6.0 and newer versions.
+     *
+     * Returns a status of 200 to indicate success and 503 for failure.
+     * The readiness probe is normally only used to check repository startup.
+     * The liveness probe should then be used to check the repository is still responding to requests.
+     * **Note:** No authentication is required to call this endpoint.
+     *
+     * @param probeId The name of the probe:
+     * - -ready-
+     * - -live-
+     * @returns Promise<ProbeEntry>
+     */
+    getProbe(probeId) {
+        throwIfNotDefined(probeId, 'probeId');
+        const pathParams = {
+            probeId
+        };
+        return this.get({
+            path: '/probes/{probeId}',
+            pathParams
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,149 @@
+/*!
+ * @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 { NodePaging } from '../model/nodePaging';
+import { PersonPaging } from '../model/personPaging';
+import { SitePaging } from '../model/sitePaging';
+import { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+/**
+ * Queries service.
+ */
+export class QueriesApi extends BaseApi {
+    /**
+     * Find nodes
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * Gets a list of nodes that match the given search criteria.
+     *
+     * The search term is used to look for nodes that match against name, title, description, full text content or tags.
+     *
+     * The search term:
+     * - must contain a minimum of 3 alphanumeric characters
+     * - allows \"quoted term\"
+     * - can optionally use '*' for wildcard matching
+     *
+     * By default, file and folder types will be searched unless a specific type is provided as a query parameter.
+     *
+     * By default, the search will be across the repository unless a specific root node id is provided to start the search from.
+     *
+     * You can sort the result list using the **orderBy** parameter. You can specify one or more of the following fields in the **orderBy** parameter:
+     * - name
+     * - modifiedAt
+     * - createdAt
+     *
+     * @param term The term to search for.
+     * @param opts Optional parameters
+     * @returns Promise<NodePaging>
+     */
+    findNodes(term, opts) {
+        throwIfNotDefined(term, 'term');
+        const queryParams = {
+            term,
+            rootNodeId: opts?.rootNodeId,
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            nodeType: opts?.nodeType,
+            include: buildCollectionParam(opts?.include, 'csv'),
+            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/queries/nodes',
+            queryParams,
+            returnType: NodePaging
+        });
+    }
+    /**
+     * Find people
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * Gets a list of people that match the given search criteria.
+     *
+     * The search term is used to look for matches against person id, firstname and lastname.
+     *
+     * The search term:
+     * - must contain a minimum of 2 alphanumeric characters
+     * - can optionally use '*' for wildcard matching within the term
+     *
+     * You can sort the result list using the **orderBy** parameter. You can specify one or more of the following fields in the **orderBy** parameter:
+     * - id
+     * - firstName
+     * - lastName
+     *
+     * @param term The term to search for.
+     * @param opts Optional parameters
+     * @returns Promise<PersonPaging>
+     */
+    findPeople(term, opts) {
+        throwIfNotDefined(term, 'term');
+        opts = opts || {};
+        const queryParams = {
+            term,
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            fields: buildCollectionParam(opts?.fields, 'csv'),
+            orderBy: buildCollectionParam(opts?.orderBy, 'csv')
+        };
+        return this.get({
+            path: '/queries/people',
+            queryParams,
+            returnType: PersonPaging
+        });
+    }
+    /**
+     * Find sites
+     *
+     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.
+     *
+     * Gets a list of sites that match the given search criteria.
+     *
+     * The search term is used to look for sites that match against site id, title or description.
+     *
+     * The search term:
+     * - must contain a minimum of 2 alphanumeric characters
+     * - can optionally use '*' for wildcard matching within the term
+     *
+     * The default sort order for the returned list is for sites to be sorted by ascending id.
+     * You can override the default by using the **orderBy** parameter. You can specify one or more of the following fields in the **orderBy** parameter:
+     * - id
+     * - title
+     * - description
+     *
+     * @param term The term to search for.
+     * @param opts Optional parameters
+     * @returns Promise<SitePaging>
+     */
+    findSites(term, opts) {
+        throwIfNotDefined(term, 'term');
+        const queryParams = {
+            term,
+            skipCount: opts?.skipCount,
+            maxItems: opts?.maxItems,
+            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),
+            fields: buildCollectionParam(opts?.fields, 'csv')
+        };
+        return this.get({
+            path: '/queries/sites',
+            queryParams,
+            returnType: SitePaging
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queries.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/content-rest-api/api/queries.api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAiClE;;GAEG;AACH,MAAM,OAAO,UAAW,SAAQ,OAAO;IACnC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,SAAS,CAAC,IAAY,EAAE,IAAqF;QACzG,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAEhC,MAAM,WAAW,GAAG;YAChB,IAAI;YACJ,UAAU,EAAE,IAAI,EAAE,UAAU;YAC5B,SAAS,EAAE,IAAI,EAAE,SAAS;YAC1B,QAAQ,EAAE,IAAI,EAAE,QAAQ;YACxB,QAAQ,EAAE,IAAI,EAAE,QAAQ;YACxB,OAAO,EAAE,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC;YACnD,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,gBAAgB;YACtB,WAAW;YACX,UAAU,EAAE,UAAU;SACzB,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,UAAU,CAAC,IAAY,EAAE,IAAgB;QACrC,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAChC,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAElB,MAAM,WAAW,GAAG;YAChB,IAAI;YACJ,SAAS,EAAE,IAAI,EAAE,SAAS;YAC1B,QAAQ,EAAE,IAAI,EAAE,QAAQ;YACxB,MAAM,EAAE,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC;YACjD,OAAO,EAAE,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC;SACtD,CAAC;QAEF,OAAO,IAAI,CAAC,GAAG,CAAC;YACZ,IAAI,EAAE,iBAAiB;YACvB,WAAW;YACX,UAAU,EAAE,YAAY;SAC3B,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,SAAS,CAAC,IAAY,EAAE,IAAgB;QACpC,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAEhC,MAAM,WAAW,GAAG;YAChB,IAAI;YACJ,SAAS,EAAE,IAAI,EAAE,SAAS;YAC1B,QAAQ,EAAE,IAAI,EAAE,QAAQ;YACxB,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,gBAAgB;YACtB,WAAW;YACX,UAAU,EAAE,UAAU;SACzB,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 { NodePaging } from '../model/nodePaging';\nimport { PersonPaging } from '../model/personPaging';\nimport { SitePaging } from '../model/sitePaging';\nimport { BaseApi } from './base.api';\nimport { throwIfNotDefined } from '../../../assert';\nimport { buildCollectionParam } from '../../../alfrescoApiClient';\nimport { ContentFieldsQuery, ContentIncludeQuery, ContentPagingQuery } from './types';\n\nexport type FindQuery = {\n    /**\n     * The term to search for.\n     */\n    term?: string;\n    /**\n     * A string to control the order of the entities returned in a list. You can use the **orderBy** parameter to\n     * sort the list by one or more fields.\n     *\n     * Each field has a default sort order, which is normally ascending order. Read the API method implementation notes\n     * above to check if any fields used in this method have a descending default search order.\n     *\n     * To sort the entities in a specific order, you can use the **ASC** and **DESC** keywords for any field.\n     */\n    orderBy?: string[];\n} & ContentPagingQuery &\n    ContentFieldsQuery;\n\nexport type FindNodesQuery = {\n    /**\n     * The id of the node to start the search from.\n     * Supports the aliases **-my-**, **-root-** and **-shared-**.\n     */\n    rootNodeId?: string;\n    /**\n     * Restrict the returned results to only those of the given node type and its sub-types\n     */\n    nodeType?: string;\n} & FindQuery;\n\n/**\n * Queries service.\n */\nexport class QueriesApi extends BaseApi {\n    /**\n     * Find nodes\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * Gets a list of nodes that match the given search criteria.\n     *\n     * The search term is used to look for nodes that match against name, title, description, full text content or tags.\n     *\n     * The search term:\n     * - must contain a minimum of 3 alphanumeric characters\n     * - allows \\\"quoted term\\\"\n     * - can optionally use '*' for wildcard matching\n     *\n     * By default, file and folder types will be searched unless a specific type is provided as a query parameter.\n     *\n     * By default, the search will be across the repository unless a specific root node id is provided to start the search from.\n     *\n     * You can sort the result list using the **orderBy** parameter. You can specify one or more of the following fields in the **orderBy** parameter:\n     * - name\n     * - modifiedAt\n     * - createdAt\n     *\n     * @param term The term to search for.\n     * @param opts Optional parameters\n     * @returns Promise<NodePaging>\n     */\n    findNodes(term: string, opts?: FindNodesQuery & ContentPagingQuery & ContentIncludeQuery & ContentFieldsQuery): Promise<NodePaging> {\n        throwIfNotDefined(term, 'term');\n\n        const queryParams = {\n            term,\n            rootNodeId: opts?.rootNodeId,\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            nodeType: opts?.nodeType,\n            include: buildCollectionParam(opts?.include, 'csv'),\n            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/queries/nodes',\n            queryParams,\n            returnType: NodePaging\n        });\n    }\n\n    /**\n     * Find people\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * Gets a list of people that match the given search criteria.\n     *\n     * The search term is used to look for matches against person id, firstname and lastname.\n     *\n     * The search term:\n     * - must contain a minimum of 2 alphanumeric characters\n     * - can optionally use '*' for wildcard matching within the term\n     *\n     * You can sort the result list using the **orderBy** parameter. You can specify one or more of the following fields in the **orderBy** parameter:\n     * - id\n     * - firstName\n     * - lastName\n     *\n     * @param term The term to search for.\n     * @param opts Optional parameters\n     * @returns Promise<PersonPaging>\n     */\n    findPeople(term: string, opts?: FindQuery): Promise<PersonPaging> {\n        throwIfNotDefined(term, 'term');\n        opts = opts || {};\n\n        const queryParams = {\n            term,\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            fields: buildCollectionParam(opts?.fields, 'csv'),\n            orderBy: buildCollectionParam(opts?.orderBy, 'csv')\n        };\n\n        return this.get({\n            path: '/queries/people',\n            queryParams,\n            returnType: PersonPaging\n        });\n    }\n\n    /**\n     * Find sites\n     *\n     * **Note:** this endpoint is available in Alfresco 5.2 and newer versions.\n     *\n     * Gets a list of sites that match the given search criteria.\n     *\n     * The search term is used to look for sites that match against site id, title or description.\n     *\n     * The search term:\n     * - must contain a minimum of 2 alphanumeric characters\n     * - can optionally use '*' for wildcard matching within the term\n     *\n     * The default sort order for the returned list is for sites to be sorted by ascending id.\n     * You can override the default by using the **orderBy** parameter. You can specify one or more of the following fields in the **orderBy** parameter:\n     * - id\n     * - title\n     * - description\n     *\n     * @param term The term to search for.\n     * @param opts Optional parameters\n     * @returns Promise<SitePaging>\n     */\n    findSites(term: string, opts?: FindQuery): Promise<SitePaging> {\n        throwIfNotDefined(term, 'term');\n\n        const queryParams = {\n            term,\n            skipCount: opts?.skipCount,\n            maxItems: opts?.maxItems,\n            orderBy: buildCollectionParam(opts?.orderBy, 'csv'),\n            fields: buildCollectionParam(opts?.fields, 'csv')\n        };\n\n        return this.get({\n            path: '/queries/sites',\n            queryParams,\n            returnType: SitePaging\n        });\n    }\n}\n"]}