@alfresco/js-api 7.3.0-1530 → 7.3.0

package/esm2020/api/activiti-rest-api/api/endpoints.api.mjs

@@ -0,0 +1,50 @@
+/*!
+ * @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';
+/**
+ * Endpoints service.
+ */
+export class EndpointsApi extends BaseApi {
+    /**
+     * Get an endpoint configuration
+     *
+     * @param endpointConfigurationId endpointConfigurationId
+     * @return Promise<EndpointConfigurationRepresentation>
+     */
+    getEndpointConfiguration(endpointConfigurationId) {
+        throwIfNotDefined(endpointConfigurationId, 'endpointConfigurationId');
+        const pathParams = {
+            endpointConfigurationId
+        };
+        return this.get({
+            path: '/api/enterprise/editor/endpoints/{endpointConfigurationId}',
+            pathParams
+        });
+    }
+    /**
+     * List endpoint configurations
+     *
+     * @return Promise<EndpointConfigurationRepresentation>
+     */
+    getEndpointConfigurations() {
+        return this.get({
+            path: '/api/enterprise/editor/endpoints'
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/activiti-rest-api/api/formModels.api.mjs

@@ -0,0 +1,150 @@
+/*!
+ * @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 { FormRepresentation, ResultListDataRepresentationFormRepresentation } from '../model';
+import { BaseApi } from './base.api';
+import { buildCollectionParam } from '../../../alfrescoApiClient';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * FormModelsApi service.
+ */
+export class FormModelsApi extends BaseApi {
+    /**
+     * Get form content
+     *
+     * @param formId formId
+     * @return Promise<FormDefinitionRepresentation>
+     */
+    getFormEditorJson(formId) {
+        throwIfNotDefined(formId, 'formId');
+        const pathParams = {
+            formId
+        };
+        return this.get({
+            path: '/api/enterprise/forms/{formId}/editorJson',
+            pathParams
+        });
+    }
+    /**
+     * Get form history
+     *
+     * @param formId formId
+     * @param formHistoryId formHistoryId
+     * @return Promise<FormRepresentation>
+     */
+    getFormHistory(formId, formHistoryId) {
+        throwIfNotDefined(formId, 'formId');
+        throwIfNotDefined(formHistoryId, 'formHistoryId');
+        const pathParams = {
+            formId,
+            formHistoryId
+        };
+        return this.get({
+            path: '/api/enterprise/editor/form-models/{formId}/history/{formHistoryId}',
+            pathParams,
+            returnType: FormRepresentation
+        });
+    }
+    /**
+     * Get a form model
+     *
+     * @param formId {number} formId
+     * @return Promise<FormRepresentation>
+     */
+    getForm(formId) {
+        throwIfNotDefined(formId, 'formId');
+        const pathParams = {
+            formId
+        };
+        return this.get({
+            path: '/api/enterprise/editor/form-models/{formId}',
+            pathParams,
+            returnType: FormRepresentation
+        });
+    }
+    /**
+     * Get forms
+     *
+     * @param input input
+     * @return Promise<FormRepresentation>
+     */
+    getForms(input) {
+        if (typeof input === 'string') {
+            const queryParams = {
+                formId: buildCollectionParam(input, 'multi')
+            };
+            return this.get({
+                path: '/api/enterprise/editor/form-models/values',
+                queryParams,
+                returnType: FormRepresentation
+            });
+        }
+        else if (typeof input === 'object') {
+            return this.get({
+                path: '/api/enterprise/forms',
+                queryParams: input
+            });
+        }
+        else {
+            return this.get({
+                path: '/api/enterprise/editor/form-models',
+                returnType: ResultListDataRepresentationFormRepresentation
+            });
+        }
+    }
+    /**
+     * Update form model content
+     *
+     * @param formId ID of the form to update
+     * @param saveRepresentation saveRepresentation
+     * @return Promise<FormRepresentation>
+     */
+    saveForm(formId, saveRepresentation) {
+        throwIfNotDefined(formId, 'formId');
+        throwIfNotDefined(saveRepresentation, 'saveRepresentation');
+        const pathParams = {
+            formId
+        };
+        return this.put({
+            path: '/api/enterprise/editor/form-models/{formId}',
+            pathParams,
+            bodyParam: saveRepresentation,
+            returnType: FormRepresentation
+        });
+    }
+    /**
+     * Validate form model content
+     *
+     * The model content to be validated must be specified in the POST body
+     *
+     * @param formId formId
+     * @param saveRepresentation saveRepresentation
+     * @return Promise<ValidationErrorRepresentation>
+     */
+    validateModel(formId, saveRepresentation) {
+        throwIfNotDefined(formId, 'formId');
+        throwIfNotDefined(saveRepresentation, 'saveRepresentation');
+        const pathParams = {
+            formId
+        };
+        return this.get({
+            path: '/api/enterprise/editor/form-models/{formId}/validate',
+            pathParams,
+            bodyParam: saveRepresentation
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formModels.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/activiti-rest-api/api/formModels.api.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n    FormDefinitionRepresentation,\n    FormRepresentation,\n    FormSaveRepresentation,\n    ResultListDataRepresentationFormRepresentation,\n    ResultListDataRepresentationRuntimeFormRepresentation,\n    ValidationErrorRepresentation\n} from '../model';\nimport { BaseApi } from './base.api';\nimport { buildCollectionParam } from '../../../alfrescoApiClient';\nimport { throwIfNotDefined } from '../../../assert';\n\nexport interface GetFormsOpts {\n    nameLike?: string;\n    appId?: number;\n    tenantId?: number;\n    start?: number;\n    sort?: string;\n    order?: string;\n    size?: number;\n}\n\n/**\n * FormModelsApi service.\n */\nexport class FormModelsApi extends BaseApi {\n    /**\n     * Get form content\n     *\n     * @param formId formId\n     * @return Promise<FormDefinitionRepresentation>\n     */\n    getFormEditorJson(formId: number): Promise<FormDefinitionRepresentation> {\n        throwIfNotDefined(formId, 'formId');\n\n        const pathParams = {\n            formId\n        };\n\n        return this.get({\n            path: '/api/enterprise/forms/{formId}/editorJson',\n            pathParams\n        });\n    }\n\n    /**\n     * Get form history\n     *\n     * @param formId formId\n     * @param formHistoryId formHistoryId\n     * @return Promise<FormRepresentation>\n     */\n    getFormHistory(formId: number, formHistoryId: number): Promise<FormRepresentation> {\n        throwIfNotDefined(formId, 'formId');\n        throwIfNotDefined(formHistoryId, 'formHistoryId');\n\n        const pathParams = {\n            formId,\n            formHistoryId\n        };\n\n        return this.get({\n            path: '/api/enterprise/editor/form-models/{formId}/history/{formHistoryId}',\n            pathParams,\n            returnType: FormRepresentation\n        });\n    }\n\n    /**\n     * Get a form model\n     *\n     * @param formId {number} formId\n     * @return Promise<FormRepresentation>\n     */\n    getForm(formId: number): Promise<FormRepresentation> {\n        throwIfNotDefined(formId, 'formId');\n\n        const pathParams = {\n            formId\n        };\n\n        return this.get({\n            path: '/api/enterprise/editor/form-models/{formId}',\n            pathParams,\n            returnType: FormRepresentation\n        });\n    }\n\n    /**\n     * Get forms\n     *\n     * @param input input\n     * @return Promise<FormRepresentation>\n     */\n    getForms(\n        input: string[] | GetFormsOpts\n    ): Promise<FormRepresentation | ResultListDataRepresentationRuntimeFormRepresentation | ResultListDataRepresentationFormRepresentation> {\n        if (typeof input === 'string') {\n            const queryParams = {\n                formId: buildCollectionParam(input, 'multi')\n            };\n\n            return this.get({\n                path: '/api/enterprise/editor/form-models/values',\n                queryParams,\n                returnType: FormRepresentation\n            });\n        } else if (typeof input === 'object') {\n            return this.get({\n                path: '/api/enterprise/forms',\n                queryParams: input\n            });\n        } else {\n            return this.get({\n                path: '/api/enterprise/editor/form-models',\n                returnType: ResultListDataRepresentationFormRepresentation\n            });\n        }\n    }\n\n    /**\n     * Update form model content\n     *\n     * @param formId ID of the form to update\n     * @param saveRepresentation saveRepresentation\n     * @return Promise<FormRepresentation>\n     */\n    saveForm(formId: number, saveRepresentation: FormSaveRepresentation): Promise<FormRepresentation> {\n        throwIfNotDefined(formId, 'formId');\n        throwIfNotDefined(saveRepresentation, 'saveRepresentation');\n\n        const pathParams = {\n            formId\n        };\n\n        return this.put({\n            path: '/api/enterprise/editor/form-models/{formId}',\n            pathParams,\n            bodyParam: saveRepresentation,\n            returnType: FormRepresentation\n        });\n    }\n\n    /**\n     * Validate form model content\n     *\n     * The model content to be validated must be specified in the POST body\n     *\n     * @param formId formId\n     * @param saveRepresentation saveRepresentation\n     * @return Promise<ValidationErrorRepresentation>\n     */\n    validateModel(formId: number, saveRepresentation: FormSaveRepresentation): Promise<ValidationErrorRepresentation> {\n        throwIfNotDefined(formId, 'formId');\n        throwIfNotDefined(saveRepresentation, 'saveRepresentation');\n\n        const pathParams = {\n            formId\n        };\n\n        return this.get({\n            path: '/api/enterprise/editor/form-models/{formId}/validate',\n            pathParams,\n            bodyParam: saveRepresentation\n        });\n    }\n}\n"]}

package/esm2020/api/activiti-rest-api/api/groups.api.mjs

@@ -0,0 +1,52 @@
+/*!
+ * @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';
+/**
+ * Groups service.
+ */
+export class ActivitiGroupsApi extends BaseApi {
+    /**
+     * Query groups
+     *
+     * @param opts Optional parameters
+     * @return Promise<ResultListDataRepresentationLightGroupRepresentation>
+     */
+    getGroups(opts) {
+        return this.get({
+            path: '/api/enterprise/groups',
+            queryParams: opts
+        });
+    }
+    /**
+     * List members of a group
+     *
+     * @param groupId groupId
+     * @return Promise<ResultListDataRepresentationLightUserRepresentation>
+     */
+    getUsersForGroup(groupId) {
+        throwIfNotDefined(groupId, 'formId');
+        const pathParams = {
+            groupId
+        };
+        return this.get({
+            path: '/api/enterprise/groups/{groupId}/users',
+            pathParams
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/activiti-rest-api/api/iDMSync.api.mjs

@@ -0,0 +1,58 @@
+/*!
+ * @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 { SyncLogEntryRepresentation } from '../model/syncLogEntryRepresentation';
+import { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * IDMSyncApi service.
+ */
+export class IDMSyncApi extends BaseApi {
+    /**
+     * Get log file for a sync log entry
+     *
+     * @param syncLogEntryId syncLogEntryId
+     * @return Promise<{}>
+     */
+    getLogFile(syncLogEntryId) {
+        throwIfNotDefined(syncLogEntryId, 'syncLogEntryId');
+        const pathParams = {
+            syncLogEntryId
+        };
+        return this.get({
+            path: '/api/enterprise/idm-sync-log-entries/{syncLogEntryId}/logfile',
+            pathParams
+        });
+    }
+    /**
+     * List sync log entries
+     *
+     * @param opts Optional parameters
+     * @param opts.tenantId {number} tenantId
+     * @param opts.page {number} page
+     * @param opts.start {number} start
+     * @param opts.size {number} size
+     * @return Promise<SyncLogEntryRepresentation>
+     */
+    getSyncLogEntries(opts) {
+        return this.get({
+            path: '/api/enterprise/idm-sync-log-entries',
+            queryParams: opts,
+            returnType: SyncLogEntryRepresentation
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/activiti-rest-api/api/index.mjs

@@ -0,0 +1,62 @@
+/*!
+ * @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 './about.api';
+export * from './accountIntegration.api';
+export * from './adminEndpoints.api';
+export * from './adminGroups.api';
+export * from './adminTenants.api';
+export * from './adminUsers.api';
+export * from './appDefinitions.api';
+export * from './checklists.api';
+export * from './comments.api';
+import { ContentApi as ActivitiContentApi } from './content.api';
+export { ActivitiContentApi };
+export * from './dataSources.api';
+export * from './decisionAudits.api';
+export * from './decisionTables.api';
+export * from './endpoints.api';
+export * from './formModels.api';
+export * from './groups.api';
+export * from './iDMSync.api';
+export * from './integrationAlfrescoCloud.api';
+export * from './integrationAlfrescoOnPremise.api';
+export * from './integrationBox.api';
+export * from './integrationDrive.api';
+export * from './models.api';
+export * from './modelsBpmn.api';
+export * from './modelsHistory.api';
+export * from './processDefinitions.api';
+export * from './processInstances.api';
+export * from './processInstanceVariables.api';
+export * from './processScopes.api';
+export * from './runtimeAppDefinitions.api';
+export * from './runtimeAppDeployments.api';
+export * from './scriptFiles.api';
+export * from './submittedForms.api';
+export * from './systemProperties.api';
+export * from './taskActions.api';
+export * from './taskForms.api';
+export * from './tasks.api';
+export * from './taskVariables.api';
+export * from './userFilters.api';
+export * from './userProfile.api';
+export * from './users.api';
+export * from './report.api';
+export * from './modelJsonBpmn.api';
+export * from './temporary.api';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/activiti-rest-api/api/integrationAlfrescoCloud.api.mjs

@@ -0,0 +1,127 @@
+/*!
+ * @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';
+/**
+ * IntegrationAlfrescoCloudApi service.
+ */
+export class IntegrationAlfrescoCloudApi extends BaseApi {
+    /**
+     * Alfresco Cloud Authorization
+     * Returns Alfresco OAuth HTML Page
+     *
+     * @param code code
+     * @return Promise<{}>
+     */
+    confirmAuthorisation(code) {
+        throwIfNotDefined(code, 'code');
+        const queryParams = {
+            code
+        };
+        return this.get({
+            path: '/api/enterprise/integration/alfresco-cloud/confirm-auth-request',
+            queryParams,
+            accepts: ['text/html']
+        });
+    }
+    /**
+     * List Alfresco networks
+     *
+     * @return Promise<ResultListDataRepresentationAlfrescoNetworkRepresenation>
+     */
+    getAllNetworks() {
+        return this.get({
+            path: '/api/enterprise/integration/alfresco-cloud/networks'
+        });
+    }
+    /**
+     * List Alfresco sites
+     * Returns ALL Sites
+     *
+     * @param networkId networkId
+     * @return Promise<ResultListDataRepresentationAlfrescoSiteRepresenation>
+     */
+    getAllSites(networkId) {
+        throwIfNotDefined(networkId, 'networkId');
+        const pathParams = {
+            networkId
+        };
+        return this.get({
+            path: '/api/enterprise/integration/alfresco-cloud/networks/{networkId}/sites',
+            pathParams
+        });
+    }
+    /**
+     * List files and folders inside a specific folder identified by path
+     *
+     * @param networkId networkId
+     * @param opts Optional parameters
+     * @param opts.siteId {string} siteId
+     * @param opts.path {string} path
+     * @return Promise<ResultListDataRepresentationAlfrescoContentRepresentation>
+     */
+    getContentInFolderPath(networkId, opts) {
+        throwIfNotDefined(networkId, 'networkId');
+        const pathParams = {
+            networkId
+        };
+        return this.get({
+            path: '/api/enterprise/integration/alfresco-cloud/networks/{networkId}/sites/{siteId}/folderpath/{folderPath}/content',
+            pathParams,
+            queryParams: opts
+        });
+    }
+    /**
+     * List files and folders inside a specific folder
+     *
+     * @param networkId networkId
+     * @param folderId folderId
+     * @return Promise<ResultListDataRepresentationAlfrescoContentRepresentation>
+     */
+    getContentInFolder(networkId, folderId) {
+        throwIfNotDefined(networkId, 'networkId');
+        throwIfNotDefined(folderId, 'folderId');
+        const pathParams = {
+            networkId,
+            folderId
+        };
+        return this.get({
+            path: '/api/enterprise/integration/alfresco-cloud/networks/{networkId}/folders/{folderId}/content',
+            pathParams
+        });
+    }
+    /**
+     * List files and folders inside a specific site
+     *
+     * @param networkId networkId
+     * @param siteId siteId
+     * @return Promise<ResultListDataRepresentationAlfrescoContentRepresentation>
+     */
+    getContentInSite(networkId, siteId) {
+        throwIfNotDefined(networkId, 'networkId');
+        throwIfNotDefined(siteId, 'siteId');
+        const pathParams = {
+            networkId,
+            siteId
+        };
+        return this.get({
+            path: '/api/enterprise/integration/alfresco-cloud/networks/{networkId}/sites/{siteId}/content',
+            pathParams
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"integrationAlfrescoCloud.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/activiti-rest-api/api/integrationAlfrescoCloud.api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;GAEG;AACH,MAAM,OAAO,2BAA4B,SAAQ,OAAO;IACpD;;;;;;OAMG;IACH,oBAAoB,CAAC,IAAY;QAC7B,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAEhC,MAAM,WAAW,GAAG;YAChB,IAAI;SACP,CAAC;QAEF,OAAO,IAAI,CAAC,GAAG,CAAC;YACZ,IAAI,EAAE,iEAAiE;YACvE,WAAW;YACX,OAAO,EAAE,CAAC,WAAW,CAAC;SACzB,CAAC,CAAC;IACP,CAAC;IAED;;;;OAIG;IACH,cAAc;QACV,OAAO,IAAI,CAAC,GAAG,CAAC;YACZ,IAAI,EAAE,qDAAqD;SAC9D,CAAC,CAAC;IACP,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CAAC,SAAiB;QACzB,iBAAiB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAE1C,MAAM,UAAU,GAAG;YACf,SAAS;SACZ,CAAC;QAEF,OAAO,IAAI,CAAC,GAAG,CAAC;YACZ,IAAI,EAAE,uEAAuE;YAC7E,UAAU;SACb,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;OAQG;IACH,sBAAsB,CAClB,SAAiB,EACjB,IAAyC;QAEzC,iBAAiB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAE1C,MAAM,UAAU,GAAG;YACf,SAAS;SACZ,CAAC;QAEF,OAAO,IAAI,CAAC,GAAG,CAAC;YACZ,IAAI,EAAE,gHAAgH;YACtH,UAAU;YACV,WAAW,EAAE,IAAI;SACpB,CAAC,CAAC;IACP,CAAC;IAED;;;;;;OAMG;IACH,kBAAkB,CAAC,SAAiB,EAAE,QAAgB;QAClD,iBAAiB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAC1C,iBAAiB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QAExC,MAAM,UAAU,GAAG;YACf,SAAS;YACT,QAAQ;SACX,CAAC;QAEF,OAAO,IAAI,CAAC,GAAG,CAAC;YACZ,IAAI,EAAE,4FAA4F;YAClG,UAAU;SACb,CAAC,CAAC;IACP,CAAC;IAED;;;;;;OAMG;IACH,gBAAgB,CAAC,SAAiB,EAAE,MAAc;QAC9C,iBAAiB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAC1C,iBAAiB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAEpC,MAAM,UAAU,GAAG;YACf,SAAS;YACT,MAAM;SACT,CAAC;QAEF,OAAO,IAAI,CAAC,GAAG,CAAC;YACZ,IAAI,EAAE,wFAAwF;YAC9F,UAAU;SACb,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 {\n    ResultListDataRepresentationAlfrescoContentRepresentation,\n    ResultListDataRepresentationAlfrescoNetworkRepresenation,\n    ResultListDataRepresentationAlfrescoSiteRepresenation\n} from '../model';\nimport { BaseApi } from './base.api';\nimport { throwIfNotDefined } from '../../../assert';\n\n/**\n * IntegrationAlfrescoCloudApi service.\n */\nexport class IntegrationAlfrescoCloudApi extends BaseApi {\n    /**\n     * Alfresco Cloud Authorization\n     * Returns Alfresco OAuth HTML Page\n     *\n     * @param code code\n     * @return Promise<{}>\n     */\n    confirmAuthorisation(code: string): Promise<any> {\n        throwIfNotDefined(code, 'code');\n\n        const queryParams = {\n            code\n        };\n\n        return this.get({\n            path: '/api/enterprise/integration/alfresco-cloud/confirm-auth-request',\n            queryParams,\n            accepts: ['text/html']\n        });\n    }\n\n    /**\n     * List Alfresco networks\n     *\n     * @return Promise<ResultListDataRepresentationAlfrescoNetworkRepresenation>\n     */\n    getAllNetworks(): Promise<ResultListDataRepresentationAlfrescoNetworkRepresenation> {\n        return this.get({\n            path: '/api/enterprise/integration/alfresco-cloud/networks'\n        });\n    }\n\n    /**\n     * List Alfresco sites\n     * Returns ALL Sites\n     *\n     * @param networkId networkId\n     * @return Promise<ResultListDataRepresentationAlfrescoSiteRepresenation>\n     */\n    getAllSites(networkId: string): Promise<ResultListDataRepresentationAlfrescoSiteRepresenation> {\n        throwIfNotDefined(networkId, 'networkId');\n\n        const pathParams = {\n            networkId\n        };\n\n        return this.get({\n            path: '/api/enterprise/integration/alfresco-cloud/networks/{networkId}/sites',\n            pathParams\n        });\n    }\n\n    /**\n     * List files and folders inside a specific folder identified by path\n     *\n     * @param networkId networkId\n     * @param opts Optional parameters\n     * @param opts.siteId {string} siteId\n     * @param opts.path {string} path\n     * @return Promise<ResultListDataRepresentationAlfrescoContentRepresentation>\n     */\n    getContentInFolderPath(\n        networkId: string,\n        opts?: { siteId?: string; path?: string }\n    ): Promise<ResultListDataRepresentationAlfrescoContentRepresentation> {\n        throwIfNotDefined(networkId, 'networkId');\n\n        const pathParams = {\n            networkId\n        };\n\n        return this.get({\n            path: '/api/enterprise/integration/alfresco-cloud/networks/{networkId}/sites/{siteId}/folderpath/{folderPath}/content',\n            pathParams,\n            queryParams: opts\n        });\n    }\n\n    /**\n     * List files and folders inside a specific folder\n     *\n     * @param networkId networkId\n     * @param folderId folderId\n     * @return Promise<ResultListDataRepresentationAlfrescoContentRepresentation>\n     */\n    getContentInFolder(networkId: string, folderId: string): Promise<ResultListDataRepresentationAlfrescoContentRepresentation> {\n        throwIfNotDefined(networkId, 'networkId');\n        throwIfNotDefined(folderId, 'folderId');\n\n        const pathParams = {\n            networkId,\n            folderId\n        };\n\n        return this.get({\n            path: '/api/enterprise/integration/alfresco-cloud/networks/{networkId}/folders/{folderId}/content',\n            pathParams\n        });\n    }\n\n    /**\n     * List files and folders inside a specific site\n     *\n     * @param networkId networkId\n     * @param siteId siteId\n     * @return Promise<ResultListDataRepresentationAlfrescoContentRepresentation>\n     */\n    getContentInSite(networkId: string, siteId: string): Promise<ResultListDataRepresentationAlfrescoContentRepresentation> {\n        throwIfNotDefined(networkId, 'networkId');\n        throwIfNotDefined(siteId, 'siteId');\n\n        const pathParams = {\n            networkId,\n            siteId\n        };\n\n        return this.get({\n            path: '/api/enterprise/integration/alfresco-cloud/networks/{networkId}/sites/{siteId}/content',\n            pathParams\n        });\n    }\n}\n"]}