@alfresco/js-api 7.3.0-1530 → 7.3.0

package/esm2020/alfrescoApiClient.mjs

@@ -0,0 +1,297 @@
+/*!
+ * @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 ee from 'event-emitter';
+import { SuperagentHttpClient } from './superagentHttpClient';
+import { paramToString } from './utils';
+import { Storage } from './storage';
+/**
+ * Builds a string representation of an array-type actual parameter, according to the given collection format.
+ *
+ * @param param An array parameter.
+ * @param collectionFormat The array element separator strategy.
+ * @returns A string representation of the supplied collection, using the specified delimiter. Returns
+ * <code>param</code> as is if <code>collectionFormat</code> is <code>multi</code>.
+ */
+export function buildCollectionParam(param, collectionFormat) {
+    if (!param) {
+        return null;
+    }
+    switch (collectionFormat) {
+        case 'csv':
+            return param.map(paramToString).join(',');
+        case 'ssv':
+            return param.map(paramToString).join(' ');
+        case 'tsv':
+            return param.map(paramToString).join('\t');
+        case 'pipes':
+            return param.map(paramToString).join('|');
+        case 'multi':
+            // return the array directly as SuperAgent will handle it as expected
+            return param.map(paramToString);
+        default:
+            throw new Error('Unknown collection format: ' + collectionFormat);
+    }
+}
+export class AlfrescoApiClient {
+    constructor(host, httpClient) {
+        /**
+         * The base URL against which to resolve every API call's (relative) path.
+         */
+        this.basePath = '';
+        /**
+         * The authentication methods to be included for all API calls.
+         */
+        this.authentications = {
+            basicAuth: {
+                ticket: ''
+            },
+            type: 'basic'
+        };
+        /**
+         * The default HTTP headers to be included for all API calls.
+         */
+        this.defaultHeaders = {};
+        /**
+         * The default HTTP timeout for all API calls.
+         */
+        this.timeout = undefined;
+        this.contentTypes = {
+            JSON: ['application/json']
+        };
+        this.host = host;
+        this.storage = Storage.getInstance();
+        // fallback for backward compatibility
+        this.httpClient = httpClient || new SuperagentHttpClient();
+        ee(this);
+    }
+    request(options) {
+        return this.buildRequestCall(this.basePath, options, this.httpClient.request.bind(this.httpClient));
+    }
+    post(options) {
+        const url = this.getCallApiUrl(options);
+        return this.buildRequestCall(url, options, this.httpClient.post.bind(this.httpClient));
+    }
+    put(options) {
+        const url = this.getCallApiUrl(options);
+        return this.buildRequestCall(url, options, this.httpClient.put.bind(this.httpClient));
+    }
+    get(options) {
+        const url = this.getCallApiUrl(options);
+        return this.buildRequestCall(url, options, this.httpClient.get.bind(this.httpClient));
+    }
+    delete(options) {
+        const url = this.getCallApiUrl(options);
+        return this.buildRequestCall(url, options, this.httpClient.delete.bind(this.httpClient));
+    }
+    callApi(path, httpMethod, pathParams, queryParams, headerParams, formParams, bodyParam, contentTypes, accepts, returnType, contextRoot, responseType, url) {
+        const callApiUrl = url ?? this.getCallApiUrl({ contextRoot, path, pathParams });
+        const options = {
+            path,
+            httpMethod,
+            pathParams,
+            queryParams,
+            headerParams,
+            formParams,
+            bodyParam,
+            contentTypes,
+            accepts,
+            returnType,
+            contextRoot,
+            responseType,
+            url
+        };
+        return this.buildRequestCall(callApiUrl, options, this.httpClient.request.bind(this.httpClient));
+    }
+    callCustomApi(path, httpMethod, pathParams, queryParams, headerParams, formParams, bodyParam, contentTypes, accepts, returnType, contextRoot, responseType) {
+        const customApiUrl = AlfrescoApiClient.buildUrl(path, '', pathParams);
+        const options = {
+            path,
+            httpMethod,
+            pathParams,
+            queryParams,
+            headerParams,
+            formParams,
+            bodyParam,
+            contentTypes,
+            accepts,
+            returnType,
+            contextRoot,
+            responseType
+        };
+        return this.buildRequestCall(customApiUrl, options, this.httpClient.request.bind(this.httpClient));
+    }
+    isCsrfEnabled() {
+        if (this.config) {
+            return !this.config.disableCsrf;
+        }
+        else {
+            return true;
+        }
+    }
+    isBpmRequest() {
+        return this.className === 'ProcessAuth' || this.className === 'ProcessClient';
+    }
+    basicAuth(username, password) {
+        const str = username + ':' + password;
+        let base64;
+        if (typeof Buffer === 'function') {
+            base64 = Buffer.from(str, 'binary').toString('base64');
+        }
+        else {
+            base64 = btoa(str);
+        }
+        return 'Basic ' + base64;
+    }
+    isWithCredentials() {
+        return !!this.config?.withCredentials;
+    }
+    getAlfTicket(ticket) {
+        const ticketParam = this.isWithCredentials() ? '&ticket=' : '&alf_ticket=';
+        if (ticket) {
+            return ticketParam + ticket;
+        }
+        else if (this.config.ticketEcm) {
+            return ticketParam + this.config.ticketEcm;
+        }
+        else if (this.storage.getItem('ticket-ECM')) {
+            return ticketParam + this.storage.getItem('ticket-ECM');
+        }
+        return '';
+    }
+    /**
+     * Builds full URL by appending the given path to the base URL and replacing path parameter place-holders
+     * with parameter values
+     */
+    static buildUrl(basePath, path, pathParams) {
+        if (path && path !== '' && !path.match(/^\//)) {
+            path = '/' + path;
+        }
+        const url = basePath + path;
+        return AlfrescoApiClient.addParamsToUrl(url, pathParams);
+    }
+    static addParamsToUrl(path, pathParams) {
+        return path.replace(/\{([\w-]+)}/g, (fullMatch, key) => {
+            let value;
+            if (Object.prototype.hasOwnProperty.call(pathParams, key)) {
+                value = paramToString(pathParams[key]);
+            }
+            else {
+                value = fullMatch;
+            }
+            return encodeURIComponent(value);
+        });
+    }
+    getCallApiUrl({ contextRoot, path, pathParams }) {
+        const basePath = contextRoot ? `${this.host}/${contextRoot}` : this.basePath;
+        return AlfrescoApiClient.buildUrl(basePath, path, pathParams);
+    }
+    buildRequestCall(url, options, httpCall) {
+        const security = this.getSecurityOptions();
+        const emitters = this.getEventEmitters();
+        const httpRequestOptions = this.getRequestOptionsWithAcceptAndContentType(options);
+        const promise = httpCall(url, httpRequestOptions, security, emitters);
+        return this.addPromiseListeners(promise, emitters.eventEmitter);
+    }
+    getSecurityOptions() {
+        return {
+            isBpmRequest: this.isBpmRequest(),
+            enableCsrf: this.isCsrfEnabled(),
+            withCredentials: this.isWithCredentials(),
+            authentications: this.authentications,
+            defaultHeaders: this.defaultHeaders
+        };
+    }
+    getEventEmitters() {
+        const apiClientEmitter = {
+            on: this.on.bind(this),
+            off: this.off.bind(this),
+            once: this.once.bind(this),
+            emit: this.emit.bind(this)
+        };
+        return {
+            apiClientEmitter,
+            eventEmitter: ee({})
+        };
+    }
+    getRequestOptionsWithAcceptAndContentType(options) {
+        const contentType = AlfrescoApiClient.jsonPreferredMime(options.contentTypes);
+        const accept = AlfrescoApiClient.jsonPreferredMime(options.accepts);
+        return {
+            ...options,
+            contentType,
+            accept
+        };
+    }
+    /**
+     * Chooses a content type from the given array, with JSON preferred; i.e. return JSON if included, otherwise return the first.
+     *
+     * @param contentTypes content types
+     * @returns The chosen content type, preferring JSON.
+     */
+    static jsonPreferredMime(contentTypes) {
+        if (!contentTypes?.length) {
+            return 'application/json';
+        }
+        for (const item of contentTypes) {
+            if (AlfrescoApiClient.isJsonMime(item)) {
+                return item;
+            }
+        }
+        return contentTypes[0];
+    }
+    /**
+     * Checks whether the given content type represents JSON.<br>
+     *
+     * JSON content type examples:<br>
+     * <ul>
+     * <li>application/json</li>
+     * <li>application/json; charset=UTF8</li>
+     * <li>APPLICATION/JSON</li>
+     * </ul>
+     *
+     * @param contentType The MIME content type to check.
+     * @returns <code>true</code> if <code>contentType</code> represents JSON, otherwise <code>false</code>.
+     */
+    static isJsonMime(contentType) {
+        return Boolean(contentType?.match(/^application\/json(;.*)?$/i));
+    }
+    addPromiseListeners(promise, eventEmitter) {
+        return Object.assign(promise, {
+            on() {
+                // eslint-disable-next-line prefer-spread,prefer-rest-params
+                eventEmitter.on.apply(eventEmitter, arguments);
+                return this;
+            },
+            once() {
+                // eslint-disable-next-line prefer-spread,prefer-rest-params
+                eventEmitter.once.apply(eventEmitter, arguments);
+                return this;
+            },
+            emit() {
+                // eslint-disable-next-line prefer-spread,prefer-rest-params
+                eventEmitter.emit.apply(eventEmitter, arguments);
+                return this;
+            },
+            off() {
+                // eslint-disable-next-line prefer-spread,prefer-rest-params
+                eventEmitter.off.apply(eventEmitter, arguments);
+                return this;
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alfrescoApiClient.js","sourceRoot":"","sources":["../../../../lib/js-api/src/alfrescoApiClient.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 ee from 'event-emitter';\nimport { AlfrescoApiConfig } from './alfrescoApiConfig';\nimport { Authentication } from './authentication/authentication';\nimport { SuperagentHttpClient } from './superagentHttpClient';\nimport { Emitters, HttpClient, LegacyHttpClient, RequestOptions, SecurityOptions } from './api-clients/http-client.interface';\nimport { paramToString } from './utils';\nimport { Storage } from './storage';\n\ndeclare const Buffer: any;\n\nexport type AlfrescoApiClientPromise<T = any> = Promise<T> & {\n    on: ee.EmitterMethod;\n    off: ee.EmitterMethod;\n    once: ee.EmitterMethod;\n    emit: (type: string, ...args: any[]) => void;\n    abort?: () => void;\n};\n\n/**\n * Builds a string representation of an array-type actual parameter, according to the given collection format.\n *\n * @param param An array parameter.\n * @param collectionFormat The array element separator strategy.\n * @returns A string representation of the supplied collection, using the specified delimiter. Returns\n * <code>param</code> as is if <code>collectionFormat</code> is <code>multi</code>.\n */\nexport function buildCollectionParam(param: string[], collectionFormat: string): string | any[] {\n    if (!param) {\n        return null;\n    }\n\n    switch (collectionFormat) {\n        case 'csv':\n            return param.map(paramToString).join(',');\n        case 'ssv':\n            return param.map(paramToString).join(' ');\n        case 'tsv':\n            return param.map(paramToString).join('\\t');\n        case 'pipes':\n            return param.map(paramToString).join('|');\n        case 'multi':\n            // return the array directly as SuperAgent will handle it as expected\n            return param.map(paramToString);\n        default:\n            throw new Error('Unknown collection format: ' + collectionFormat);\n    }\n}\n\nexport class AlfrescoApiClient implements ee.Emitter, LegacyHttpClient {\n    on: ee.EmitterMethod;\n    off: ee.EmitterMethod;\n    once: ee.EmitterMethod;\n    emit: (type: string, ...args: any[]) => void;\n\n    storage: Storage;\n    host: string;\n    className: string;\n    config: AlfrescoApiConfig;\n    url: string;\n    /**\n     * The base URL against which to resolve every API call's (relative) path.\n     */\n    basePath = '';\n\n    /**\n     * The authentication methods to be included for all API calls.\n     */\n    authentications: Authentication = {\n        basicAuth: {\n            ticket: ''\n        },\n        type: 'basic'\n    };\n    /**\n     * The default HTTP headers to be included for all API calls.\n     */\n    defaultHeaders = {};\n\n    /**\n     * The default HTTP timeout for all API calls.\n     */\n    timeout: number | { deadline?: number; response?: number } = undefined;\n\n    contentTypes = {\n        JSON: ['application/json']\n    };\n\n    httpClient: HttpClient;\n\n    constructor(host?: string, httpClient?: HttpClient) {\n        this.host = host;\n\n        this.storage = Storage.getInstance();\n\n        // fallback for backward compatibility\n        this.httpClient = httpClient || new SuperagentHttpClient();\n\n        ee(this);\n    }\n\n    request<T = any>(options: RequestOptions): Promise<T> {\n        return this.buildRequestCall(this.basePath, options, this.httpClient.request.bind(this.httpClient));\n    }\n\n    post<T = any>(options: RequestOptions): AlfrescoApiClientPromise<T> {\n        const url = this.getCallApiUrl(options);\n        return this.buildRequestCall(url, options, this.httpClient.post.bind(this.httpClient));\n    }\n\n    put<T = any>(options: RequestOptions): AlfrescoApiClientPromise<T> {\n        const url = this.getCallApiUrl(options);\n        return this.buildRequestCall(url, options, this.httpClient.put.bind(this.httpClient));\n    }\n\n    get<T = any>(options: RequestOptions): AlfrescoApiClientPromise<T> {\n        const url = this.getCallApiUrl(options);\n        return this.buildRequestCall(url, options, this.httpClient.get.bind(this.httpClient));\n    }\n\n    delete<T = void>(options: RequestOptions): AlfrescoApiClientPromise<T> {\n        const url = this.getCallApiUrl(options);\n        return this.buildRequestCall<T>(url, options, this.httpClient.delete.bind(this.httpClient));\n    }\n\n    callApi(\n        path: string,\n        httpMethod: string,\n        pathParams?: any,\n        queryParams?: any,\n        headerParams?: any,\n        formParams?: any,\n        bodyParam?: any,\n        contentTypes?: string[],\n        accepts?: string[],\n        returnType?: any,\n        contextRoot?: string,\n        responseType?: string,\n        url?: string\n    ): AlfrescoApiClientPromise<any> {\n        const callApiUrl = url ?? this.getCallApiUrl({ contextRoot, path, pathParams });\n\n        const options: RequestOptions = {\n            path,\n            httpMethod,\n            pathParams,\n            queryParams,\n            headerParams,\n            formParams,\n            bodyParam,\n            contentTypes,\n            accepts,\n            returnType,\n            contextRoot,\n            responseType,\n            url\n        };\n\n        return this.buildRequestCall(callApiUrl, options, this.httpClient.request.bind(this.httpClient));\n    }\n\n    callCustomApi(\n        path: string,\n        httpMethod: string,\n        pathParams?: any,\n        queryParams?: any,\n        headerParams?: any,\n        formParams?: any,\n        bodyParam?: any,\n        contentTypes?: string[],\n        accepts?: string[],\n        returnType?: any,\n        contextRoot?: string,\n        responseType?: string\n    ): AlfrescoApiClientPromise<any> {\n        const customApiUrl = AlfrescoApiClient.buildUrl(path, '', pathParams);\n        const options: RequestOptions = {\n            path,\n            httpMethod,\n            pathParams,\n            queryParams,\n            headerParams,\n            formParams,\n            bodyParam,\n            contentTypes,\n            accepts,\n            returnType,\n            contextRoot,\n            responseType\n        };\n\n        return this.buildRequestCall(customApiUrl, options, this.httpClient.request.bind(this.httpClient));\n    }\n\n    isCsrfEnabled(): boolean {\n        if (this.config) {\n            return !this.config.disableCsrf;\n        } else {\n            return true;\n        }\n    }\n\n    isBpmRequest(): boolean {\n        return this.className === 'ProcessAuth' || this.className === 'ProcessClient';\n    }\n\n    basicAuth(username: string, password: string): string {\n        const str = username + ':' + password;\n\n        let base64;\n\n        if (typeof Buffer === 'function') {\n            base64 = Buffer.from(str, 'binary').toString('base64');\n        } else {\n            base64 = btoa(str);\n        }\n\n        return 'Basic ' + base64;\n    }\n\n    isWithCredentials(): boolean {\n        return !!this.config?.withCredentials;\n    }\n\n    getAlfTicket(ticket: string): string {\n        const ticketParam = this.isWithCredentials() ? '&ticket=' : '&alf_ticket=';\n\n        if (ticket) {\n            return ticketParam + ticket;\n        } else if (this.config.ticketEcm) {\n            return ticketParam + this.config.ticketEcm;\n        } else if (this.storage.getItem('ticket-ECM')) {\n            return ticketParam + this.storage.getItem('ticket-ECM');\n        }\n\n        return '';\n    }\n\n    /**\n     * Builds full URL by appending the given path to the base URL and replacing path parameter place-holders\n     * with parameter values\n     */\n    private static buildUrl(basePath: string, path: string, pathParams: any): string {\n        if (path && path !== '' && !path.match(/^\\//)) {\n            path = '/' + path;\n        }\n        const url = basePath + path;\n\n        return AlfrescoApiClient.addParamsToUrl(url, pathParams);\n    }\n\n    private static addParamsToUrl(path: string, pathParams: any) {\n        return path.replace(/\\{([\\w-]+)}/g, (fullMatch, key) => {\n            let value;\n\n            if (Object.prototype.hasOwnProperty.call(pathParams, key)) {\n                value = paramToString(pathParams[key]);\n            } else {\n                value = fullMatch;\n            }\n\n            return encodeURIComponent(value);\n        });\n    }\n\n    private getCallApiUrl({ contextRoot, path, pathParams }: { contextRoot?: string; path: string; pathParams?: any }): string {\n        const basePath = contextRoot ? `${this.host}/${contextRoot}` : this.basePath;\n\n        return AlfrescoApiClient.buildUrl(basePath, path, pathParams);\n    }\n\n    private buildRequestCall<T = any>(\n        url: string,\n        options: RequestOptions,\n        httpCall: (url: string, options: RequestOptions, security: SecurityOptions, emitters: Emitters) => Promise<T>\n    ): AlfrescoApiClientPromise<T> {\n        const security = this.getSecurityOptions();\n        const emitters = this.getEventEmitters();\n        const httpRequestOptions = this.getRequestOptionsWithAcceptAndContentType(options);\n        const promise = httpCall(url, httpRequestOptions, security, emitters);\n\n        return this.addPromiseListeners(promise, emitters.eventEmitter);\n    }\n\n    private getSecurityOptions(): SecurityOptions {\n        return {\n            isBpmRequest: this.isBpmRequest(),\n            enableCsrf: this.isCsrfEnabled(),\n            withCredentials: this.isWithCredentials(),\n            authentications: this.authentications,\n            defaultHeaders: this.defaultHeaders\n        };\n    }\n\n    private getEventEmitters(): Emitters {\n        const apiClientEmitter = {\n            on: this.on.bind(this),\n            off: this.off.bind(this),\n            once: this.once.bind(this),\n            emit: this.emit.bind(this)\n        };\n\n        return {\n            apiClientEmitter,\n            eventEmitter: ee({})\n        };\n    }\n\n    private getRequestOptionsWithAcceptAndContentType(options: RequestOptions): RequestOptions {\n        const contentType = AlfrescoApiClient.jsonPreferredMime(options.contentTypes);\n        const accept = AlfrescoApiClient.jsonPreferredMime(options.accepts);\n\n        return {\n            ...options,\n            contentType,\n            accept\n        };\n    }\n\n    /**\n     * Chooses a content type from the given array, with JSON preferred; i.e. return JSON if included, otherwise return the first.\n     *\n     * @param contentTypes content types\n     * @returns The chosen content type, preferring JSON.\n     */\n    private static jsonPreferredMime(contentTypes: readonly string[]): string {\n        if (!contentTypes?.length) {\n            return 'application/json';\n        }\n\n        for (const item of contentTypes) {\n            if (AlfrescoApiClient.isJsonMime(item)) {\n                return item;\n            }\n        }\n        return contentTypes[0];\n    }\n\n    /**\n     * Checks whether the given content type represents JSON.<br>\n     *\n     * JSON content type examples:<br>\n     * <ul>\n     * <li>application/json</li>\n     * <li>application/json; charset=UTF8</li>\n     * <li>APPLICATION/JSON</li>\n     * </ul>\n     *\n     * @param contentType The MIME content type to check.\n     * @returns <code>true</code> if <code>contentType</code> represents JSON, otherwise <code>false</code>.\n     */\n    private static isJsonMime(contentType: string): boolean {\n        return Boolean(contentType?.match(/^application\\/json(;.*)?$/i));\n    }\n\n    private addPromiseListeners<T = any>(promise: Promise<T>, eventEmitter: ee.Emitter): AlfrescoApiClientPromise<T> {\n        return Object.assign(promise, {\n            on() {\n                // eslint-disable-next-line prefer-spread,prefer-rest-params\n                eventEmitter.on.apply(eventEmitter, arguments);\n                return this;\n            },\n            once() {\n                // eslint-disable-next-line prefer-spread,prefer-rest-params\n                eventEmitter.once.apply(eventEmitter, arguments);\n                return this;\n            },\n            emit() {\n                // eslint-disable-next-line prefer-spread,prefer-rest-params\n                eventEmitter.emit.apply(eventEmitter, arguments);\n                return this;\n            },\n            off() {\n                // eslint-disable-next-line prefer-spread,prefer-rest-params\n                eventEmitter.off.apply(eventEmitter, arguments);\n                return this;\n            }\n        });\n    }\n}\n"]}

package/esm2020/alfrescoApiConfig.mjs

@@ -0,0 +1,44 @@
+/*!
+ * @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 class AlfrescoApiConfig {
+    constructor(input = { oauth2: {} }) {
+        this.hostEcm = 'http://127.0.0.1:8080';
+        this.hostBpm = 'http://127.0.0.1:9999';
+        this.authType = 'BASIC';
+        this.contextRoot = 'alfresco';
+        this.tenant = '-default-';
+        this.contextRootBpm = 'activiti-app';
+        this.domainPrefix = '';
+        this.provider = 'ECM';
+        this.disableCsrf = false;
+        this.withCredentials = false;
+        this.oauthInit = true;
+        Object.assign(this, input);
+        this.hostEcm = input.hostEcm ? input.hostEcm : 'http://127.0.0.1:8080';
+        this.hostBpm = input.hostBpm ? input.hostBpm : 'http://127.0.0.1:9999';
+        this.authType = input.authType ? input.authType : 'BASIC';
+        this.contextRoot = input.contextRoot ? input.contextRoot : 'alfresco';
+        this.contextRootBpm = input.contextRootBpm ? input.contextRootBpm : 'activiti-app';
+        this.tenant = input.tenant ? input.tenant : '-default-';
+        this.provider = input.provider ? input.provider : 'ECM';
+        this.disableCsrf = input.disableCsrf ? input.disableCsrf : false;
+        this.domainPrefix = input.domainPrefix ? input.domainPrefix : '';
+        this.withCredentials = input.withCredentials ? input.withCredentials : false;
+        this.oauth2 = input.oauth2;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,34 @@
+/*!
+ * @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';
+/**
+ * About service.
+ */
+export class AboutApi extends BaseApi {
+    /**
+     * Get server type and version
+     * Provides information about the running Alfresco Process Services Suite. The response payload object has the properties type, majorVersion, minorVersion, revisionVersion and edition.
+     *
+     * @return Promise<{ [key: string]: string; }>
+     */
+    getAppVersion() {
+        return this.get({
+            path: '/api/enterprise/app-version'
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,34 @@
+/*!
+ * @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';
+/**
+ * AccountIntegrationApi service.
+ */
+export class AccountIntegrationApi extends BaseApi {
+    /**
+     * Retrieve external account information
+     * Accounts are used to integrate with third party apps and clients
+     *
+     * @return Promise<ResultListDataRepresentationAccountRepresentation>
+     */
+    getAccounts() {
+        return this.get({
+            path: '/api/enterprise/account/integration'
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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