@alfresco/adf-process-services-cloud 8.1.0-16295248176 → 8.1.0-16342534841

package/esm2022/lib/process/start-process/models/process-instance-cloud.model.mjs

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

package/esm2022/lib/process/start-process/models/process-payload-cloud.model.mjs

@@ -0,0 +1,26 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 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 ProcessPayloadCloud {
+    constructor(obj) {
+        this.payloadType = 'StartProcessPayload';
+        this.processDefinitionKey = obj?.processDefinitionKey;
+        this.name = obj?.name;
+        this.businessKey = obj?.businessKey;
+        this.variables = obj?.variables || {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/process/start-process/models/process-with-form-payload-cloud.model.mjs

@@ -0,0 +1,26 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 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 ProcessWithFormPayloadCloud {
+    constructor(obj) {
+        this.processName = obj.processName;
+        this.processDefinitionKey = obj.processDefinitionKey;
+        this.variables = obj.variables;
+        this.values = obj.values;
+        this.outcome = obj.outcome;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/process/start-process/public-api.mjs

@@ -0,0 +1,21 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 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 './components/start-process-cloud.component';
+export * from './models/process-instance-cloud.model';
+export * from './models/process-payload-cloud.model';
+export * from './services/start-process-cloud.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9wcm9jZXNzLXNlcnZpY2VzLWNsb3VkL3NyYy9saWIvcHJvY2Vzcy9zdGFydC1wcm9jZXNzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyw0Q0FBNEMsQ0FBQztBQUMzRCxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyx3Q0FBd0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL3N0YXJ0LXByb2Nlc3MtY2xvdWQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3Byb2Nlc3MtaW5zdGFuY2UtY2xvdWQubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvcHJvY2Vzcy1wYXlsb2FkLWNsb3VkLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvc3RhcnQtcHJvY2Vzcy1jbG91ZC5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/process/start-process/services/start-process-cloud.service.mjs

@@ -0,0 +1,125 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 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 { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ProcessDefinitionCloud } from '../../../models/process-definition-cloud.model';
+import { BaseCloudService } from '../../../services/base-cloud.service';
+import { TaskVariableCloud } from '../../../form/models/task-variable-cloud.model';
+import * as i0 from "@angular/core";
+export class StartProcessCloudService extends BaseCloudService {
+    /**
+     * Gets the process definitions associated with an app.
+     *
+     * @param appName Name of the target app
+     * @param queryParams optional query parameters
+     * @returns Array of process definitions
+     */
+    getProcessDefinitions(appName, queryParams) {
+        if (appName || appName === '') {
+            const url = `${this.getBasePath(appName)}/rb/v1/process-definitions`;
+            return this.get(url, queryParams).pipe(map((res) => res.list.entries.map((processDefs) => new ProcessDefinitionCloud(processDefs.entry))));
+        }
+        else {
+            return throwError('AppName not configured');
+        }
+    }
+    /**
+     * Starts a process based on a process definition, name, form values or variables.
+     *
+     * @param appName name of the Application
+     * @param payload Details of the process (definition key, name, variables, etc)
+     * @returns Details of the process instance just started
+     */
+    startProcess(appName, payload) {
+        const url = `${this.getBasePath(appName)}/rb/v1/process-instances`;
+        payload.payloadType = 'StartProcessPayload';
+        return this.post(url, payload).pipe(map((result) => result.entry));
+    }
+    startProcessWithForm(appName, formId, version, payload) {
+        const url = `${this.getBasePath(appName)}/form/v1/forms/${formId}/submit/versions/${version}`;
+        payload.payloadType = 'StartProcessPayload';
+        return this.post(url, payload);
+    }
+    /**
+     * Update an existing process instance
+     *
+     * @param appName name of the Application
+     * @param processInstanceId process instance to update
+     * @param payload Details of the process (definition key, name, variables, etc)
+     * @returns Details of the process instance just started
+     */
+    updateProcess(appName, processInstanceId, payload) {
+        const url = `${this.getBasePath(appName)}/rb/v1/process-instances/${processInstanceId}`;
+        payload.payloadType = 'UpdateProcessPayload';
+        return this.put(url, payload).pipe(map((processInstance) => processInstance.entry));
+    }
+    /**
+     * Delete an existing process instance
+     *
+     * @param appName Application name
+     * @param processInstanceId the identifier of the process instance to update
+     * @returns Observable<void>
+     */
+    deleteProcess(appName, processInstanceId) {
+        const url = `${this.getBasePath(appName)}/rb/v1/process-instances/${processInstanceId}`;
+        return this.delete(url);
+    }
+    /**
+     * Gets the static values mapped to the start form of a process definition.
+     *
+     * @param appName Name of the app
+     * @param processDefinitionId ID of the target process definition
+     * @returns Static mappings for the start event
+     */
+    getStartEventFormStaticValuesMapping(appName, processDefinitionId) {
+        const apiUrl = `${this.getBasePath(appName)}/rb/v1/process-definitions/${processDefinitionId}/static-values`;
+        return this.get(apiUrl).pipe(map((res) => {
+            const result = [];
+            if (res) {
+                Object.keys(res).forEach((mapping) => result.push(new TaskVariableCloud({ name: mapping, value: res[mapping] })));
+            }
+            return result;
+        }));
+    }
+    /**
+     * Gets the constants mapped to the start form of a process definition.
+     *
+     * @param appName Name of the app
+     * @param processDefinitionId ID of the target process definition
+     * @returns Constants values for the start event
+     */
+    getStartEventConstants(appName, processDefinitionId) {
+        const apiUrl = `${this.getBasePath(appName)}/rb/v1/process-definitions/${processDefinitionId}/constant-values`;
+        return this.get(apiUrl).pipe(map((res) => {
+            const result = [];
+            if (res) {
+                Object.keys(res).forEach((constant) => result.push(new TaskVariableCloud({ name: constant, value: res[constant], type: 'string' })));
+            }
+            return result;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StartProcessCloudService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StartProcessCloudService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StartProcessCloudService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"start-process-cloud.service.js","sourceRoot":"","sources":["../../../../../../../../lib/process-services-cloud/src/lib/process/start-process/services/start-process-cloud.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 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 { Injectable } from '@angular/core';\nimport { Observable, throwError } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { ProcessInstanceCloud } from '../models/process-instance-cloud.model';\nimport { ProcessPayloadCloud } from '../models/process-payload-cloud.model';\nimport { ProcessDefinitionCloud } from '../../../models/process-definition-cloud.model';\nimport { BaseCloudService } from '../../../services/base-cloud.service';\nimport { TaskVariableCloud } from '../../../form/models/task-variable-cloud.model';\n\nexport interface QueryParams {\n    include: 'variables';\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class StartProcessCloudService extends BaseCloudService {\n    /**\n     * Gets the process definitions associated with an app.\n     *\n     * @param appName Name of the target app\n     * @param queryParams optional query parameters\n     * @returns Array of process definitions\n     */\n    getProcessDefinitions(appName: string, queryParams?: QueryParams): Observable<ProcessDefinitionCloud[]> {\n        if (appName || appName === '') {\n            const url = `${this.getBasePath(appName)}/rb/v1/process-definitions`;\n\n            return this.get(url, queryParams).pipe(\n                map((res: any) => res.list.entries.map((processDefs) => new ProcessDefinitionCloud(processDefs.entry)))\n            );\n        } else {\n            return throwError('AppName not configured');\n        }\n    }\n\n    /**\n     * Starts a process based on a process definition, name, form values or variables.\n     *\n     * @param appName name of the Application\n     * @param payload Details of the process (definition key, name, variables, etc)\n     * @returns Details of the process instance just started\n     */\n    startProcess(appName: string, payload: ProcessPayloadCloud): Observable<ProcessInstanceCloud> {\n        const url = `${this.getBasePath(appName)}/rb/v1/process-instances`;\n        payload.payloadType = 'StartProcessPayload';\n\n        return this.post(url, payload).pipe(map((result: any) => result.entry));\n    }\n\n    startProcessWithForm(appName: string, formId: string, version: number, payload: any): Observable<ProcessInstanceCloud> {\n        const url = `${this.getBasePath(appName)}/form/v1/forms/${formId}/submit/versions/${version}`;\n        payload.payloadType = 'StartProcessPayload';\n\n        return this.post(url, payload);\n    }\n\n    /**\n     * Update an existing process instance\n     *\n     * @param appName name of the Application\n     * @param processInstanceId process instance to update\n     * @param payload Details of the process (definition key, name, variables, etc)\n     * @returns Details of the process instance just started\n     */\n    updateProcess(appName: string, processInstanceId: string, payload: ProcessPayloadCloud): Observable<ProcessInstanceCloud> {\n        const url = `${this.getBasePath(appName)}/rb/v1/process-instances/${processInstanceId}`;\n        payload.payloadType = 'UpdateProcessPayload';\n\n        return this.put(url, payload).pipe(map((processInstance: any) => processInstance.entry));\n    }\n\n    /**\n     * Delete an existing process instance\n     *\n     * @param appName Application name\n     * @param processInstanceId the identifier of the process instance to update\n     * @returns Observable<void>\n     */\n    deleteProcess(appName: string, processInstanceId: string): Observable<void> {\n        const url = `${this.getBasePath(appName)}/rb/v1/process-instances/${processInstanceId}`;\n\n        return this.delete(url);\n    }\n\n    /**\n     * Gets the static values mapped to the start form of a process definition.\n     *\n     * @param appName Name of the app\n     * @param processDefinitionId ID of the target process definition\n     * @returns Static mappings for the start event\n     */\n    getStartEventFormStaticValuesMapping(appName: string, processDefinitionId: string): Observable<TaskVariableCloud[]> {\n        const apiUrl = `${this.getBasePath(appName)}/rb/v1/process-definitions/${processDefinitionId}/static-values`;\n        return this.get(apiUrl).pipe(\n            map((res: { [key: string]: any }) => {\n                const result = [];\n                if (res) {\n                    Object.keys(res).forEach((mapping) => result.push(new TaskVariableCloud({ name: mapping, value: res[mapping] })));\n                }\n                return result;\n            })\n        );\n    }\n\n    /**\n     * Gets the constants mapped to the start form of a process definition.\n     *\n     * @param appName Name of the app\n     * @param processDefinitionId ID of the target process definition\n     * @returns Constants values for the start event\n     */\n    getStartEventConstants(appName: string, processDefinitionId: string): Observable<TaskVariableCloud[]> {\n        const apiUrl = `${this.getBasePath(appName)}/rb/v1/process-definitions/${processDefinitionId}/constant-values`;\n        return this.get(apiUrl).pipe(\n            map((res: { [key: string]: any }) => {\n                const result = [];\n                if (res) {\n                    Object.keys(res).forEach((constant) =>\n                        result.push(new TaskVariableCloud({ name: constant, value: res[constant], type: 'string' }))\n                    );\n                }\n                return result;\n            })\n        );\n    }\n}\n"]}

package/esm2022/lib/process-services-cloud.module.mjs

@@ -0,0 +1,103 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 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 { NgModule } from '@angular/core';
+import { provideTranslations } from '@alfresco/adf-core';
+import { APP_LIST_CLOUD_DIRECTIVES } from './app/app-list-cloud.module';
+import { TaskCloudModule } from './task/task-cloud.module';
+import { ProcessCloudModule } from './process/process-cloud.module';
+import { FORM_CLOUD_DIRECTIVES } from './form/form-cloud.module';
+import { TASK_FORM_CLOUD_DIRECTIVES } from './task/task-form/task-form.module';
+import { TASK_LIST_CLOUD_TOKEN } from './services/public-api';
+import { RichTextEditorComponent } from './rich-text-editor';
+import { GroupCloudComponent } from './group/components/group-cloud.component';
+import { PeopleCloudComponent } from './people/components/people-cloud.component';
+import { provideCloudFormRenderer, provideCloudPreferences } from './providers';
+import { TaskListCloudService } from './task/task-list/services/task-list-cloud.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./app/components/app-list-cloud/app-list-cloud.component";
+import * as i2 from "./app/components/app-details-cloud/app-details-cloud.component";
+import * as i3 from "./rich-text-editor/rich-text-editor.component";
+import * as i4 from "./form/components/spinner/form-spinner.component";
+import * as i5 from "./form/components/widgets/properties-viewer/properties-viewer-wrapper/properties-viewer-wrapper.component";
+import * as i6 from "./form/components/widgets/properties-viewer/properties-viewer.widget";
+import * as i7 from "./form/components/widgets/display-rich-text/display-rich-text.widget";
+import * as i8 from "./form/components/widgets/file-viewer/file-viewer.widget";
+import * as i9 from "./form/components/widgets/attach-file/file-properties-table/file-properties-table-cloud.component";
+import * as i10 from "./form/components/form-cloud-custom-outcomes.component";
+import * as i11 from "./form/components/form-definition-selector-cloud.component";
+import * as i12 from "./form/components/widgets/radio-buttons/radio-buttons-cloud.widget";
+import * as i13 from "./form/components/widgets/attach-file/attach-file-cloud-widget.component";
+import * as i14 from "./form/components/widgets/upload/upload-cloud.widget";
+import * as i15 from "./form/components/widgets/people/people-cloud.widget";
+import * as i16 from "./form/components/widgets/group/group-cloud.widget";
+import * as i17 from "./form/components/form-cloud.component";
+import * as i18 from "./task/task-form/components/user-task-cloud-buttons/user-task-cloud-buttons.component";
+import * as i19 from "./task/task-form/components/task-form-cloud/task-form-cloud.component";
+import * as i20 from "./task/task-form/components/user-task-cloud/user-task-cloud.component";
+export const PROCESS_SERVICES_CLOUD_DIRECTIVES = [
+    ...APP_LIST_CLOUD_DIRECTIVES,
+    ...FORM_CLOUD_DIRECTIVES,
+    ...TASK_FORM_CLOUD_DIRECTIVES,
+    PeopleCloudComponent,
+    RichTextEditorComponent
+];
+/**
+ * @deprecated this module is deprecated and will be removed in the future versions
+ *
+ * Instead, import the standalone components directly, or use the following provider API to replicate the behaviour:
+ *
+ * providers: [
+ *      provideTranslations('adf-process-services-cloud', 'assets/adf-process-services-cloud')
+ *      provideCloudPreferences()
+ *      provideCloudFormRenderer(),
+ *      { provide: TASK_LIST_CLOUD_TOKEN, useClass: TaskListCloudService }
+ * ]
+ */
+export class ProcessServicesCloudModule {
+    static forRoot(filterPreferenceServiceInstance, listPreferenceServiceInstance) {
+        return {
+            ngModule: ProcessServicesCloudModule,
+            providers: [
+                provideTranslations('adf-process-services-cloud', 'assets/adf-process-services-cloud'),
+                provideCloudPreferences({
+                    filterPreferenceServiceInstance,
+                    listPreferenceServiceInstance
+                }),
+                provideCloudFormRenderer(),
+                { provide: TASK_LIST_CLOUD_TOKEN, useClass: TaskListCloudService }
+            ]
+        };
+    }
+    static forChild() {
+        return {
+            ngModule: ProcessServicesCloudModule
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessServicesCloudModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: ProcessServicesCloudModule, imports: [ProcessCloudModule, TaskCloudModule, GroupCloudComponent, i1.AppListCloudComponent, i2.AppDetailsCloudComponent, i3.RichTextEditorComponent, i4.FormSpinnerComponent, i5.PropertiesViewerWrapperComponent, i6.PropertiesViewerWidgetComponent, i7.DisplayRichTextWidgetComponent, i8.FileViewerWidgetComponent, i9.FilePropertiesTableCloudComponent, i10.FormCustomOutcomesComponent, i11.FormDefinitionSelectorCloudComponent, i12.RadioButtonsCloudWidgetComponent, i13.AttachFileCloudWidgetComponent, i14.UploadCloudWidgetComponent, i15.PeopleCloudWidgetComponent, i16.GroupCloudWidgetComponent, i17.FormCloudComponent, i18.UserTaskCloudButtonsComponent, i19.TaskFormCloudComponent, i20.UserTaskCloudComponent, PeopleCloudComponent,
+            RichTextEditorComponent], exports: [ProcessCloudModule, TaskCloudModule, GroupCloudComponent, i1.AppListCloudComponent, i2.AppDetailsCloudComponent, i3.RichTextEditorComponent, i4.FormSpinnerComponent, i5.PropertiesViewerWrapperComponent, i6.PropertiesViewerWidgetComponent, i7.DisplayRichTextWidgetComponent, i8.FileViewerWidgetComponent, i9.FilePropertiesTableCloudComponent, i10.FormCustomOutcomesComponent, i11.FormDefinitionSelectorCloudComponent, i12.RadioButtonsCloudWidgetComponent, i13.AttachFileCloudWidgetComponent, i14.UploadCloudWidgetComponent, i15.PeopleCloudWidgetComponent, i16.GroupCloudWidgetComponent, i17.FormCloudComponent, i18.UserTaskCloudButtonsComponent, i19.TaskFormCloudComponent, i20.UserTaskCloudComponent, PeopleCloudComponent,
+            RichTextEditorComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessServicesCloudModule, imports: [ProcessCloudModule, TaskCloudModule, GroupCloudComponent, i1.AppListCloudComponent, i2.AppDetailsCloudComponent, i4.FormSpinnerComponent, i5.PropertiesViewerWrapperComponent, i6.PropertiesViewerWidgetComponent, i8.FileViewerWidgetComponent, i9.FilePropertiesTableCloudComponent, i11.FormDefinitionSelectorCloudComponent, i12.RadioButtonsCloudWidgetComponent, i13.AttachFileCloudWidgetComponent, i14.UploadCloudWidgetComponent, i15.PeopleCloudWidgetComponent, i16.GroupCloudWidgetComponent, i17.FormCloudComponent, i18.UserTaskCloudButtonsComponent, i19.TaskFormCloudComponent, i20.UserTaskCloudComponent, PeopleCloudComponent, ProcessCloudModule, TaskCloudModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessServicesCloudModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ProcessCloudModule, TaskCloudModule, GroupCloudComponent, ...PROCESS_SERVICES_CLOUD_DIRECTIVES],
+                    exports: [ProcessCloudModule, TaskCloudModule, GroupCloudComponent, ...PROCESS_SERVICES_CLOUD_DIRECTIVES]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/providers.mjs

@@ -0,0 +1,45 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 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 { PROCESS_FILTERS_SERVICE_TOKEN, PROCESS_LISTS_PREFERENCES_SERVICE_TOKEN, TASK_FILTERS_SERVICE_TOKEN, TASK_LIST_PREFERENCES_SERVICE_TOKEN } from './services/cloud-token.service';
+import { LocalPreferenceCloudService } from './services/local-preference-cloud.service';
+import { FormRenderingService } from '@alfresco/adf-core';
+import { CloudFormRenderingService } from './form/components/cloud-form-rendering.service';
+/**
+ * Provides preferences service for the process services cloud components
+ *
+ * @param opts Optional settings
+ * @param opts.filterPreferenceServiceInstance Custom filter instance for `PROCESS_FILTERS_SERVICE_TOKEN` and `TASK_FILTERS_SERVICE_TOKEN` (default: LocalPreferenceCloudService)
+ * @param opts.listPreferenceServiceInstance Custom filter instance for `PROCESS_LISTS_PREFERENCES_SERVICE_TOKEN` and `TASK_LIST_PREFERENCES_SERVICE_TOKEN` (default: LocalPreferenceCloudService)
+ * @returns list of providers
+ */
+export function provideCloudPreferences(opts) {
+    return [
+        { provide: PROCESS_FILTERS_SERVICE_TOKEN, useExisting: opts?.filterPreferenceServiceInstance ?? LocalPreferenceCloudService },
+        { provide: TASK_FILTERS_SERVICE_TOKEN, useExisting: opts?.filterPreferenceServiceInstance ?? LocalPreferenceCloudService },
+        { provide: PROCESS_LISTS_PREFERENCES_SERVICE_TOKEN, useExisting: opts?.listPreferenceServiceInstance ?? LocalPreferenceCloudService },
+        { provide: TASK_LIST_PREFERENCES_SERVICE_TOKEN, useExisting: opts?.listPreferenceServiceInstance ?? LocalPreferenceCloudService }
+    ];
+}
+/**
+ * Provides form rendering services for process cloud components
+ *
+ * @returns list of providers
+ */
+export function provideCloudFormRenderer() {
+    return [FormRenderingService, { provide: FormRenderingService, useClass: CloudFormRenderingService }];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/rich-text-editor/editorjs-config.mjs

@@ -0,0 +1,101 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 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.
+ */
+/** Plugin import */
+import CodeTool from '@editorjs/code';
+import Header from '@editorjs/header';
+import Paragraph from '@editorjs/paragraph';
+import InlineCode from '@editorjs/inline-code';
+import List from '@editorjs/list';
+import Marker from '@editorjs/marker';
+import Underline from '@editorjs/underline';
+import ChangeFontSize from '@valano/change-font-size';
+import ColorPlugin from 'editorjs-text-color-plugin';
+import AlignmentTuneTool from 'editorjs-text-alignment-blocktune';
+export const editorJsConfig = {
+    autofocus: true,
+    logLevel: 'ERROR',
+    tools: {
+        underline: {
+            class: Underline,
+            shortcut: 'CMD+U'
+        },
+        header: {
+            class: Header,
+            inlineToolbar: true,
+            tunes: ['anyTuneName']
+        },
+        paragraph: {
+            class: Paragraph,
+            inlineToolbar: true,
+            tunes: ['anyTuneName']
+        },
+        list: {
+            class: List,
+            inlineToolbar: true,
+            config: {
+                defaultStyle: 'unordered'
+            }
+        },
+        Color: {
+            class: ColorPlugin,
+            config: {
+                customPicker: true,
+                colorCollections: [
+                    '#FF1300',
+                    '#ffa500',
+                    '#9C27B0',
+                    '#673AB7',
+                    '#3F51B5',
+                    '#0070FF',
+                    '#03A9F4',
+                    '#00BCD4',
+                    '#5f9ea0',
+                    '#4CAF50',
+                    '#8BC34A',
+                    '#CDDC39',
+                    '#FFF',
+                    '#000',
+                    '#c0c0c0',
+                    '#808080',
+                    '#800000'
+                ],
+                defaultColor: '#FF1300',
+                type: 'text'
+            }
+        },
+        Marker: {
+            class: Marker,
+            shortcut: 'CMD+M'
+        },
+        'Increase/Decrease font size': {
+            class: ChangeFontSize,
+            config: {
+                cssClass: 'plus20pc',
+                buttonIcon: '<span class="material-icons">format_size</span>'
+            }
+        },
+        inlineCode: {
+            class: InlineCode,
+            shortcut: 'CMD+SHIFT+M'
+        },
+        anyTuneName: {
+            class: AlignmentTuneTool
+        },
+        code: CodeTool
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWRpdG9yanMtY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGliL3Byb2Nlc3Mtc2VydmljZXMtY2xvdWQvc3JjL2xpYi9yaWNoLXRleHQtZWRpdG9yL2VkaXRvcmpzLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxvQkFBb0I7QUFDcEIsT0FBTyxRQUFRLE1BQU0sZ0JBQWdCLENBQUM7QUFDdEMsT0FBTyxNQUFNLE1BQU0sa0JBQWtCLENBQUM7QUFDdEMsT0FBTyxTQUFTLE1BQU0scUJBQXFCLENBQUM7QUFDNUMsT0FBTyxVQUFVLE1BQU0sdUJBQXVCLENBQUM7QUFDL0MsT0FBTyxJQUFJLE1BQU0sZ0JBQWdCLENBQUM7QUFDbEMsT0FBTyxNQUFNLE1BQU0sa0JBQWtCLENBQUM7QUFDdEMsT0FBTyxTQUFTLE1BQU0scUJBQXFCLENBQUM7QUFDNUMsT0FBTyxjQUFjLE1BQU0sMEJBQTBCLENBQUM7QUFDdEQsT0FBTyxXQUFXLE1BQU0sNEJBQTRCLENBQUM7QUFDckQsT0FBTyxpQkFBaUIsTUFBTSxtQ0FBbUMsQ0FBQztBQUVsRSxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUc7SUFDMUIsU0FBUyxFQUFFLElBQUk7SUFDZixRQUFRLEVBQUUsT0FBTztJQUNqQixLQUFLLEVBQUU7UUFDSCxTQUFTLEVBQUU7WUFDUCxLQUFLLEVBQUUsU0FBUztZQUNoQixRQUFRLEVBQUUsT0FBTztTQUNwQjtRQUNELE1BQU0sRUFBRTtZQUNKLEtBQUssRUFBRSxNQUFNO1lBQ2IsYUFBYSxFQUFFLElBQUk7WUFDbkIsS0FBSyxFQUFFLENBQUMsYUFBYSxDQUFDO1NBQ3pCO1FBQ0QsU0FBUyxFQUFFO1lBQ1AsS0FBSyxFQUFFLFNBQVM7WUFDaEIsYUFBYSxFQUFFLElBQUk7WUFDbkIsS0FBSyxFQUFFLENBQUMsYUFBYSxDQUFDO1NBQ3pCO1FBQ0QsSUFBSSxFQUFFO1lBQ0YsS0FBSyxFQUFFLElBQUk7WUFDWCxhQUFhLEVBQUUsSUFBSTtZQUNuQixNQUFNLEVBQUU7Z0JBQ0osWUFBWSxFQUFFLFdBQVc7YUFDNUI7U0FDSjtRQUNELEtBQUssRUFBRTtZQUNILEtBQUssRUFBRSxXQUFXO1lBQ2xCLE1BQU0sRUFBRTtnQkFDSixZQUFZLEVBQUUsSUFBSTtnQkFDbEIsZ0JBQWdCLEVBQUU7b0JBQ2QsU0FBUztvQkFDVCxTQUFTO29CQUNULFNBQVM7b0JBQ1QsU0FBUztvQkFDVCxTQUFTO29CQUNULFNBQVM7b0JBQ1QsU0FBUztvQkFDVCxTQUFTO29CQUNULFNBQVM7b0JBQ1QsU0FBUztvQkFDVCxTQUFTO29CQUNULFNBQVM7b0JBQ1QsTUFBTTtvQkFDTixNQUFNO29CQUNOLFNBQVM7b0JBQ1QsU0FBUztvQkFDVCxTQUFTO2lCQUNaO2dCQUNELFlBQVksRUFBRSxTQUFTO2dCQUN2QixJQUFJLEVBQUUsTUFBTTthQUNmO1NBQ0o7UUFDRCxNQUFNLEVBQUU7WUFDSixLQUFLLEVBQUUsTUFBTTtZQUNiLFFBQVEsRUFBRSxPQUFPO1NBQ3BCO1FBQ0QsNkJBQTZCLEVBQUU7WUFDM0IsS0FBSyxFQUFFLGNBQWM7WUFDckIsTUFBTSxFQUFFO2dCQUNKLFFBQVEsRUFBRSxVQUFVO2dCQUNwQixVQUFVLEVBQUUsaURBQWlEO2FBQ2hFO1NBQ0o7UUFDRCxVQUFVLEVBQUU7WUFDUixLQUFLLEVBQUUsVUFBVTtZQUNqQixRQUFRLEVBQUUsYUFBYTtTQUMxQjtRQUNELFdBQVcsRUFBRTtZQUNULEtBQUssRUFBRSxpQkFBaUI7U0FDM0I7UUFDRCxJQUFJLEVBQUUsUUFBUTtLQUNqQjtDQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbi8qKiBQbHVnaW4gaW1wb3J0ICovXG5pbXBvcnQgQ29kZVRvb2wgZnJvbSAnQGVkaXRvcmpzL2NvZGUnO1xuaW1wb3J0IEhlYWRlciBmcm9tICdAZWRpdG9yanMvaGVhZGVyJztcbmltcG9ydCBQYXJhZ3JhcGggZnJvbSAnQGVkaXRvcmpzL3BhcmFncmFwaCc7XG5pbXBvcnQgSW5saW5lQ29kZSBmcm9tICdAZWRpdG9yanMvaW5saW5lLWNvZGUnO1xuaW1wb3J0IExpc3QgZnJvbSAnQGVkaXRvcmpzL2xpc3QnO1xuaW1wb3J0IE1hcmtlciBmcm9tICdAZWRpdG9yanMvbWFya2VyJztcbmltcG9ydCBVbmRlcmxpbmUgZnJvbSAnQGVkaXRvcmpzL3VuZGVybGluZSc7XG5pbXBvcnQgQ2hhbmdlRm9udFNpemUgZnJvbSAnQHZhbGFuby9jaGFuZ2UtZm9udC1zaXplJztcbmltcG9ydCBDb2xvclBsdWdpbiBmcm9tICdlZGl0b3Jqcy10ZXh0LWNvbG9yLXBsdWdpbic7XG5pbXBvcnQgQWxpZ25tZW50VHVuZVRvb2wgZnJvbSAnZWRpdG9yanMtdGV4dC1hbGlnbm1lbnQtYmxvY2t0dW5lJztcblxuZXhwb3J0IGNvbnN0IGVkaXRvckpzQ29uZmlnID0ge1xuICAgIGF1dG9mb2N1czogdHJ1ZSxcbiAgICBsb2dMZXZlbDogJ0VSUk9SJyxcbiAgICB0b29sczoge1xuICAgICAgICB1bmRlcmxpbmU6IHtcbiAgICAgICAgICAgIGNsYXNzOiBVbmRlcmxpbmUsXG4gICAgICAgICAgICBzaG9ydGN1dDogJ0NNRCtVJ1xuICAgICAgICB9LFxuICAgICAgICBoZWFkZXI6IHtcbiAgICAgICAgICAgIGNsYXNzOiBIZWFkZXIsXG4gICAgICAgICAgICBpbmxpbmVUb29sYmFyOiB0cnVlLFxuICAgICAgICAgICAgdHVuZXM6IFsnYW55VHVuZU5hbWUnXVxuICAgICAgICB9LFxuICAgICAgICBwYXJhZ3JhcGg6IHtcbiAgICAgICAgICAgIGNsYXNzOiBQYXJhZ3JhcGgsXG4gICAgICAgICAgICBpbmxpbmVUb29sYmFyOiB0cnVlLFxuICAgICAgICAgICAgdHVuZXM6IFsnYW55VHVuZU5hbWUnXVxuICAgICAgICB9LFxuICAgICAgICBsaXN0OiB7XG4gICAgICAgICAgICBjbGFzczogTGlzdCxcbiAgICAgICAgICAgIGlubGluZVRvb2xiYXI6IHRydWUsXG4gICAgICAgICAgICBjb25maWc6IHtcbiAgICAgICAgICAgICAgICBkZWZhdWx0U3R5bGU6ICd1bm9yZGVyZWQnXG4gICAgICAgICAgICB9XG4gICAgICAgIH0sXG4gICAgICAgIENvbG9yOiB7XG4gICAgICAgICAgICBjbGFzczogQ29sb3JQbHVnaW4sXG4gICAgICAgICAgICBjb25maWc6IHtcbiAgICAgICAgICAgICAgICBjdXN0b21QaWNrZXI6IHRydWUsXG4gICAgICAgICAgICAgICAgY29sb3JDb2xsZWN0aW9uczogW1xuICAgICAgICAgICAgICAgICAgICAnI0ZGMTMwMCcsXG4gICAgICAgICAgICAgICAgICAgICcjZmZhNTAwJyxcbiAgICAgICAgICAgICAgICAgICAgJyM5QzI3QjAnLFxuICAgICAgICAgICAgICAgICAgICAnIzY3M0FCNycsXG4gICAgICAgICAgICAgICAgICAgICcjM0Y1MUI1JyxcbiAgICAgICAgICAgICAgICAgICAgJyMwMDcwRkYnLFxuICAgICAgICAgICAgICAgICAgICAnIzAzQTlGNCcsXG4gICAgICAgICAgICAgICAgICAgICcjMDBCQ0Q0JyxcbiAgICAgICAgICAgICAgICAgICAgJyM1ZjllYTAnLFxuICAgICAgICAgICAgICAgICAgICAnIzRDQUY1MCcsXG4gICAgICAgICAgICAgICAgICAgICcjOEJDMzRBJyxcbiAgICAgICAgICAgICAgICAgICAgJyNDRERDMzknLFxuICAgICAgICAgICAgICAgICAgICAnI0ZGRicsXG4gICAgICAgICAgICAgICAgICAgICcjMDAwJyxcbiAgICAgICAgICAgICAgICAgICAgJyNjMGMwYzAnLFxuICAgICAgICAgICAgICAgICAgICAnIzgwODA4MCcsXG4gICAgICAgICAgICAgICAgICAgICcjODAwMDAwJ1xuICAgICAgICAgICAgICAgIF0sXG4gICAgICAgICAgICAgICAgZGVmYXVsdENvbG9yOiAnI0ZGMTMwMCcsXG4gICAgICAgICAgICAgICAgdHlwZTogJ3RleHQnXG4gICAgICAgICAgICB9XG4gICAgICAgIH0sXG4gICAgICAgIE1hcmtlcjoge1xuICAgICAgICAgICAgY2xhc3M6IE1hcmtlcixcbiAgICAgICAgICAgIHNob3J0Y3V0OiAnQ01EK00nXG4gICAgICAgIH0sXG4gICAgICAgICdJbmNyZWFzZS9EZWNyZWFzZSBmb250IHNpemUnOiB7XG4gICAgICAgICAgICBjbGFzczogQ2hhbmdlRm9udFNpemUsXG4gICAgICAgICAgICBjb25maWc6IHtcbiAgICAgICAgICAgICAgICBjc3NDbGFzczogJ3BsdXMyMHBjJyxcbiAgICAgICAgICAgICAgICBidXR0b25JY29uOiAnPHNwYW4gY2xhc3M9XCJtYXRlcmlhbC1pY29uc1wiPmZvcm1hdF9zaXplPC9zcGFuPidcbiAgICAgICAgICAgIH1cbiAgICAgICAgfSxcbiAgICAgICAgaW5saW5lQ29kZToge1xuICAgICAgICAgICAgY2xhc3M6IElubGluZUNvZGUsXG4gICAgICAgICAgICBzaG9ydGN1dDogJ0NNRCtTSElGVCtNJ1xuICAgICAgICB9LFxuICAgICAgICBhbnlUdW5lTmFtZToge1xuICAgICAgICAgICAgY2xhc3M6IEFsaWdubWVudFR1bmVUb29sXG4gICAgICAgIH0sXG4gICAgICAgIGNvZGU6IENvZGVUb29sXG4gICAgfVxufTtcbiJdfQ==

package/esm2022/lib/rich-text-editor/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 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 './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvcHJvY2Vzcy1zZXJ2aWNlcy1jbG91ZC9zcmMvbGliL3JpY2gtdGV4dC1lZGl0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/lib/rich-text-editor/public-api.mjs

@@ -0,0 +1,19 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 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 './rich-text-editor.component';
+export * from './rich-text-editor.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9wcm9jZXNzLXNlcnZpY2VzLWNsb3VkL3NyYy9saWIvcmljaC10ZXh0LWVkaXRvci9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9yaWNoLXRleHQtZWRpdG9yLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3JpY2gtdGV4dC1lZGl0b3IubW9kdWxlJztcbiJdfQ==