@alfresco/adf-content-services 8.1.0-16116688508 → 8.1.0-16117584844

package/esm2022/lib/security/services/security-controls-groups-marks-security.service.mjs

@@ -0,0 +1,274 @@
+/*!
+ * @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 { BehaviorSubject, from, Subject } from 'rxjs';
+import { SecurityGroupsApi, SecurityMarksApi, AuthorityClearanceApi } from '@alfresco/js-api';
+import { UserPreferencesService } from '@alfresco/adf-core';
+import { finalize } from 'rxjs/operators';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/alfresco-api.service";
+import * as i2 from "@alfresco/adf-core";
+const DEFAULT_SKIP_COUNT = 0;
+const DEFAULT_INCLUDE = 'inUse';
+export class SecurityControlsService {
+    constructor(apiService, userPreferencesService) {
+        this.apiService = apiService;
+        this.userPreferencesService = userPreferencesService;
+        this.groupsPaginatedSource = new Subject();
+        this.groupsPaginated$ = this.groupsPaginatedSource.asObservable();
+        this.reloadSecurityControls = new Subject();
+        this.reloadSecurityControls$ = this.reloadSecurityControls.asObservable();
+        this._reloadAuthorityClearance = new Subject();
+        this.reloadAuthorityClearance$ = this._reloadAuthorityClearance.asObservable();
+        this.marksPaginatedSource = new Subject();
+        this.marksPaginated$ = this.marksPaginatedSource.asObservable();
+        this.loadingSource = new BehaviorSubject(true);
+        this.loading$ = this.loadingSource.asObservable();
+    }
+    get groupsApi() {
+        return this.securityGroup || (this.securityGroup = new SecurityGroupsApi(this.apiService.getInstance()));
+    }
+    get marksApi() {
+        return this.securityMark || (this.securityMark = new SecurityMarksApi(this.apiService.getInstance()));
+    }
+    get authorityClearanceApi() {
+        return this.authorityClearance || (this.authorityClearance = new AuthorityClearanceApi(this.apiService.getInstance()));
+    }
+    get reloadAuthorityClearance() {
+        return this._reloadAuthorityClearance;
+    }
+    /**
+     * Get All security groups
+     *
+     * @param skipCount The number of entities that exist in the collection before those included in this list.
+     * @param maxItems The maximum number of items to return in the list. Default is specified by UserPreferencesService.
+     * @param include Additional information about the security group
+     * @returns Promise<SecurityControlsGroupResponse>
+     */
+    getSecurityGroup(skipCount = DEFAULT_SKIP_COUNT, maxItems = this.userPreferencesService.paginationSize, include = DEFAULT_INCLUDE) {
+        let securityControlsGroupResponse;
+        return new Promise((resolve, reject) => {
+            this.groupsApi
+                .getSecurityGroups({
+                include,
+                skipCount,
+                maxItems
+            })
+                .then((response) => {
+                this.groupsPaginatedSource.next((securityControlsGroupResponse = {
+                    pagination: response.list.pagination,
+                    entries: response.list.entries.map((group) => group.entry)
+                }));
+                resolve(securityControlsGroupResponse);
+            })
+                .catch((error) => reject(error));
+        });
+    }
+    /**
+     * Create security group
+     *
+     * @param input securityGroupBody.
+     * @returns Observable<SecurityGroupEntry>
+     */
+    createSecurityGroup(input) {
+        this.loadingSource.next(true);
+        const payload = {
+            ...input
+        };
+        const opts = {
+            include: DEFAULT_INCLUDE
+        };
+        const promise = this.groupsApi.createSecurityGroup(payload, opts);
+        return from(promise).pipe(finalize(() => this.loadingSource.next(false)));
+    }
+    /**
+     * Create security marks
+     *
+     * @param securityGroupId The key for the security group id.
+     * @param input securityMarkBody[].
+     * @returns Promise<SecurityMarkPaging | SecurityMarkEntry>
+     */
+    createSecurityMarks(securityGroupId, input) {
+        this.loadingSource.next(true);
+        const promise = this.marksApi
+            .createSecurityMarks(securityGroupId, input)
+            .then((result) => {
+            this.loadingSource.next(false);
+            return result;
+        })
+            .catch((error) => {
+            this.loadingSource.next(false);
+            return error;
+        });
+        return promise;
+    }
+    /**
+     * Get security mark value
+     * Gets the value for a selected **securityGroupId**.
+     *
+     * @param securityGroupId The key for the security group id.
+     * @param skipCount The number of entities that exist in the collection before those included in this list.
+     * @returns Promise<SecurityControlsMarkResponse>
+     */
+    getSecurityMark(securityGroupId, skipCount = DEFAULT_SKIP_COUNT) {
+        let securityControlsMarkResponse;
+        return new Promise((resolve, reject) => {
+            this.marksApi
+                .getSecurityMarks(securityGroupId, {
+                skipCount
+            })
+                .then((response) => {
+                this.marksPaginatedSource.next((securityControlsMarkResponse = {
+                    pagination: response.list.pagination,
+                    entries: response.list.entries.map((mark) => mark.entry)
+                }));
+                resolve(securityControlsMarkResponse);
+            })
+                .catch((error) => reject(error));
+        });
+    }
+    /**
+     * Update a security groups information
+     *
+     * @param securityGroupId The Key of Security Group id for which info is required
+     * @param input SecurityGroupBody
+     * @param opts additional information about the security group
+     * @returns Promise<SecurityGroupEntry>
+     */
+    updateSecurityGroup(securityGroupId, input, opts) {
+        this.loadingSource.next(true);
+        const payload = {
+            ...input
+        };
+        if (!opts) {
+            opts = {
+                DEFAULT_INCLUDE
+            };
+        }
+        const promise = this.groupsApi
+            .updateSecurityGroup(securityGroupId, payload, opts)
+            .then((result) => {
+            this.loadingSource.next(false);
+            return result;
+        })
+            .catch((error) => {
+            this.loadingSource.next(false);
+            return error;
+        });
+        return promise;
+    }
+    /**
+     * Updates Security Mark value
+     *
+     * @param securityGroupId The key for the security group id.
+     * @param securityMarkId The key for the security mark is in use or not.
+     * @param input securityMarkBody.
+     * @returns Promise<SecurityMarkEntry>
+     */
+    updateSecurityMark(securityGroupId, securityMarkId, input) {
+        this.loadingSource.next(true);
+        const payload = {
+            ...input
+        };
+        const promise = this.marksApi
+            .updateSecurityMark(securityGroupId, securityMarkId, payload)
+            .then((result) => {
+            this.loadingSource.next(false);
+            return result;
+        })
+            .catch((error) => {
+            this.loadingSource.next(false);
+            return error;
+        });
+        return promise;
+    }
+    /**
+     * Delete security group
+     *
+     * @param securityGroupId The key for the security group id.
+     * @returns Observable<void>
+     */
+    deleteSecurityGroup(securityGroupId) {
+        this.loadingSource.next(true);
+        const promise = this.groupsApi.deleteSecurityGroup(securityGroupId);
+        return from(promise).pipe(finalize(() => this.loadingSource.next(false)));
+    }
+    /**
+     * Delete security mark
+     *
+     * @param securityGroupId The key for the security group id.
+     * @param securityMarkId The key for the security mark id.
+     * @returns Promise<SecurityMarkEntry>
+     */
+    deleteSecurityMark(securityGroupId, securityMarkId) {
+        this.loadingSource.next(true);
+        const promise = this.marksApi
+            .deleteSecurityMark(securityGroupId, securityMarkId)
+            .then((result) => {
+            this.loadingSource.next(false);
+            return result;
+        })
+            .catch((error) => {
+            this.loadingSource.next(false);
+            return error;
+        });
+        return promise;
+    }
+    /**
+     * Get the authority clearances for a single user/group
+     *
+     * @param authorityName The name for the authority for which the clearance is to be fetched. Can be left blank in which case it will fetch it for all users with pagination
+     * @param skipCount The number of entities that exist in the collection before those included in this list.
+     * @param maxItems The maximum number of items to return in the list. Default is specified by UserPreferencesService.
+     * @returns Observable<AuthorityClearanceGroupPaging>
+     */
+    getClearancesForAuthority(authorityName, skipCount = DEFAULT_SKIP_COUNT, maxItems = this.userPreferencesService.paginationSize) {
+        this.loadingSource.next(true);
+        const opts = {
+            skipCount,
+            maxItems
+        };
+        const promise = this.authorityClearanceApi.getAuthorityClearanceForAuthority(authorityName, opts);
+        return from(promise).pipe(finalize(() => this.loadingSource.next(false)));
+    }
+    /**
+     * Updates the authority clearance.
+     *
+     * @param authorityName The name for the authority for which the clearance is to be updated
+     * @param securityMarksList NodeSecurityMarkBody[]
+     * @returns Observable<SecurityMarkEntry | SecurityMarkPaging>
+     */
+    updateClearancesForAuthority(authorityName, securityMarksList) {
+        this.loadingSource.next(true);
+        const promise = this.authorityClearanceApi.updateAuthorityClearance(authorityName, securityMarksList);
+        return from(promise).pipe(finalize(() => {
+            this.loadingSource.next(false);
+            this._reloadAuthorityClearance.next();
+        }));
+    }
+    reloadSecurityGroups() {
+        this.reloadSecurityControls.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SecurityControlsService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.UserPreferencesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SecurityControlsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SecurityControlsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.UserPreferencesService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-controls-groups-marks-security.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/security/services/security-controls-groups-marks-security.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 { BehaviorSubject, from, Observable, Subject } from 'rxjs';\nimport { SecurityControlsGroupResponse } from './models/security-controls-group-response.interface';\nimport { SecurityControlsMarkResponse } from './models/security-controls-mark-response.interface';\nimport {\n    SecurityGroupsApi,\n    SecurityMarksApi,\n    SecurityGroupEntry,\n    SecurityMarkEntry,\n    SecurityGroupBody,\n    SecurityMarkPaging,\n    SecurityMarkBody,\n    AuthorityClearanceApi,\n    AuthorityClearanceGroupPaging,\n    NodeSecurityMarkBody,\n    GsGroupInclude\n} from '@alfresco/js-api';\nimport { UserPreferencesService } from '@alfresco/adf-core';\nimport { finalize } from 'rxjs/operators';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\n\nconst DEFAULT_SKIP_COUNT = 0;\nconst DEFAULT_INCLUDE = 'inUse';\n\n@Injectable({ providedIn: 'root' })\nexport class SecurityControlsService {\n    private groupsPaginatedSource = new Subject<SecurityControlsGroupResponse>();\n    groupsPaginated$ = this.groupsPaginatedSource.asObservable();\n\n    private reloadSecurityControls: Subject<void> = new Subject<void>();\n    reloadSecurityControls$ = this.reloadSecurityControls.asObservable();\n\n    private _reloadAuthorityClearance: Subject<void> = new Subject<void>();\n    reloadAuthorityClearance$ = this._reloadAuthorityClearance.asObservable();\n\n    private marksPaginatedSource = new Subject<SecurityControlsMarkResponse>();\n    marksPaginated$ = this.marksPaginatedSource.asObservable();\n\n    private loadingSource = new BehaviorSubject<boolean>(true);\n    loading$ = this.loadingSource.asObservable();\n\n    private securityGroup: SecurityGroupsApi;\n    private securityMark: SecurityMarksApi;\n    private authorityClearance: AuthorityClearanceApi;\n    constructor(private apiService: AlfrescoApiService, private userPreferencesService: UserPreferencesService) {}\n\n    get groupsApi(): SecurityGroupsApi {\n        return this.securityGroup || (this.securityGroup = new SecurityGroupsApi(this.apiService.getInstance()));\n    }\n\n    get marksApi(): SecurityMarksApi {\n        return this.securityMark || (this.securityMark = new SecurityMarksApi(this.apiService.getInstance()));\n    }\n\n    get authorityClearanceApi(): AuthorityClearanceApi {\n        return this.authorityClearance || (this.authorityClearance = new AuthorityClearanceApi(this.apiService.getInstance()));\n    }\n\n    get reloadAuthorityClearance(): Subject<void> {\n        return this._reloadAuthorityClearance;\n    }\n\n    /**\n     * Get All security groups\n     *\n     * @param skipCount The number of entities that exist in the collection before those included in this list.\n     * @param maxItems The maximum number of items to return in the list. Default is specified by UserPreferencesService.\n     * @param include Additional information about the security group\n     * @returns Promise<SecurityControlsGroupResponse>\n     */\n    getSecurityGroup(\n        skipCount = DEFAULT_SKIP_COUNT,\n        maxItems = this.userPreferencesService.paginationSize,\n        include = DEFAULT_INCLUDE\n    ): Promise<SecurityControlsGroupResponse> {\n        let securityControlsGroupResponse: SecurityControlsGroupResponse;\n        return new Promise((resolve, reject) => {\n            this.groupsApi\n                .getSecurityGroups({\n                    include,\n                    skipCount,\n                    maxItems\n                })\n                .then((response) => {\n                    this.groupsPaginatedSource.next(\n                        (securityControlsGroupResponse = {\n                            pagination: response.list.pagination,\n                            entries: response.list.entries.map((group) => group.entry)\n                        })\n                    );\n                    resolve(securityControlsGroupResponse);\n                })\n                .catch((error) => reject(error));\n        });\n    }\n\n    /**\n     * Create security group\n     *\n     * @param input securityGroupBody.\n     * @returns Observable<SecurityGroupEntry>\n     */\n    createSecurityGroup(input: SecurityGroupBody): Observable<SecurityGroupEntry> {\n        this.loadingSource.next(true);\n        const payload: SecurityGroupBody = {\n            ...input\n        };\n        const opts: GsGroupInclude = {\n            include: DEFAULT_INCLUDE\n        };\n        const promise = this.groupsApi.createSecurityGroup(payload, opts);\n\n        return from(promise).pipe(finalize(() => this.loadingSource.next(false)));\n    }\n\n    /**\n     * Create security marks\n     *\n     * @param securityGroupId The key for the security group id.\n     * @param input securityMarkBody[].\n     * @returns Promise<SecurityMarkPaging | SecurityMarkEntry>\n     */\n    createSecurityMarks(securityGroupId: string, input: SecurityMarkBody[]): Promise<SecurityMarkPaging | SecurityMarkEntry> {\n        this.loadingSource.next(true);\n        const promise = this.marksApi\n            .createSecurityMarks(securityGroupId, input)\n            .then((result) => {\n                this.loadingSource.next(false);\n                return result;\n            })\n            .catch((error) => {\n                this.loadingSource.next(false);\n                return error;\n            });\n\n        return promise;\n    }\n\n    /**\n     * Get security mark value\n     * Gets the value for a selected **securityGroupId**.\n     *\n     * @param securityGroupId The key for the security group id.\n     * @param skipCount The number of entities that exist in the collection before those included in this list.\n     * @returns Promise<SecurityControlsMarkResponse>\n     */\n    getSecurityMark(securityGroupId: string, skipCount = DEFAULT_SKIP_COUNT): Promise<SecurityControlsMarkResponse> {\n        let securityControlsMarkResponse: SecurityControlsMarkResponse;\n        return new Promise((resolve, reject) => {\n            this.marksApi\n                .getSecurityMarks(securityGroupId, {\n                    skipCount\n                })\n                .then((response) => {\n                    this.marksPaginatedSource.next(\n                        (securityControlsMarkResponse = {\n                            pagination: response.list.pagination,\n                            entries: response.list.entries.map((mark) => mark.entry)\n                        })\n                    );\n                    resolve(securityControlsMarkResponse);\n                })\n                .catch((error) => reject(error));\n        });\n    }\n\n    /**\n     * Update a security groups information\n     *\n     * @param securityGroupId The Key of Security Group id for which info is required\n     * @param input SecurityGroupBody\n     * @param opts additional information about the security group\n     * @returns Promise<SecurityGroupEntry>\n     */\n    updateSecurityGroup(securityGroupId: string, input: SecurityGroupBody, opts?: any): Promise<SecurityGroupEntry> {\n        this.loadingSource.next(true);\n        const payload: SecurityGroupBody = {\n            ...input\n        };\n        if (!opts) {\n            opts = {\n                DEFAULT_INCLUDE\n            };\n        }\n        const promise = this.groupsApi\n            .updateSecurityGroup(securityGroupId, payload, opts)\n            .then((result) => {\n                this.loadingSource.next(false);\n                return result;\n            })\n            .catch((error) => {\n                this.loadingSource.next(false);\n                return error;\n            });\n\n        return promise;\n    }\n\n    /**\n     * Updates Security Mark value\n     *\n     * @param securityGroupId The key for the security group id.\n     * @param securityMarkId The key for the security mark is in use or not.\n     * @param input securityMarkBody.\n     * @returns Promise<SecurityMarkEntry>\n     */\n    updateSecurityMark(securityGroupId: string, securityMarkId: string, input: SecurityMarkBody): Promise<SecurityMarkEntry> {\n        this.loadingSource.next(true);\n        const payload: SecurityMarkBody = {\n            ...input\n        };\n        const promise = this.marksApi\n            .updateSecurityMark(securityGroupId, securityMarkId, payload)\n            .then((result) => {\n                this.loadingSource.next(false);\n                return result;\n            })\n            .catch((error) => {\n                this.loadingSource.next(false);\n                return error;\n            });\n\n        return promise;\n    }\n\n    /**\n     * Delete security group\n     *\n     * @param securityGroupId The key for the security group id.\n     * @returns Observable<void>\n     */\n    deleteSecurityGroup(securityGroupId: string): Observable<void> {\n        this.loadingSource.next(true);\n        const promise = this.groupsApi.deleteSecurityGroup(securityGroupId);\n\n        return from(promise).pipe(finalize(() => this.loadingSource.next(false)));\n    }\n\n    /**\n     * Delete security mark\n     *\n     * @param securityGroupId The key for the security group id.\n     * @param securityMarkId The key for the security mark id.\n     * @returns Promise<SecurityMarkEntry>\n     */\n    deleteSecurityMark(securityGroupId: string, securityMarkId: string): Promise<SecurityMarkEntry> {\n        this.loadingSource.next(true);\n        const promise = this.marksApi\n            .deleteSecurityMark(securityGroupId, securityMarkId)\n            .then((result) => {\n                this.loadingSource.next(false);\n                return result;\n            })\n            .catch((error) => {\n                this.loadingSource.next(false);\n                return error;\n            });\n\n        return promise;\n    }\n\n    /**\n     * Get the authority clearances for a single user/group\n     *\n     * @param authorityName The name for the authority for which the clearance is to be fetched. Can be left blank in which case it will fetch it for all users with pagination\n     * @param skipCount The number of entities that exist in the collection before those included in this list.\n     * @param maxItems The maximum number of items to return in the list. Default is specified by UserPreferencesService.\n     * @returns Observable<AuthorityClearanceGroupPaging>\n     */\n    getClearancesForAuthority(\n        authorityName: string,\n        skipCount = DEFAULT_SKIP_COUNT,\n        maxItems = this.userPreferencesService.paginationSize\n    ): Observable<AuthorityClearanceGroupPaging> {\n        this.loadingSource.next(true);\n        const opts = {\n            skipCount,\n            maxItems\n        };\n        const promise = this.authorityClearanceApi.getAuthorityClearanceForAuthority(authorityName, opts);\n\n        return from(promise).pipe(finalize(() => this.loadingSource.next(false)));\n    }\n\n    /**\n     * Updates the authority clearance.\n     *\n     * @param authorityName The name for the authority for which the clearance is to be updated\n     * @param securityMarksList NodeSecurityMarkBody[]\n     * @returns Observable<SecurityMarkEntry | SecurityMarkPaging>\n     */\n    updateClearancesForAuthority(\n        authorityName: string,\n        securityMarksList: NodeSecurityMarkBody[]\n    ): Observable<SecurityMarkEntry | SecurityMarkPaging> {\n        this.loadingSource.next(true);\n        const promise = this.authorityClearanceApi.updateAuthorityClearance(authorityName, securityMarksList);\n\n        return from(promise).pipe(\n            finalize(() => {\n                this.loadingSource.next(false);\n                this._reloadAuthorityClearance.next();\n            })\n        );\n    }\n\n    reloadSecurityGroups() {\n        this.reloadSecurityControls.next();\n    }\n}\n"]}

package/esm2022/lib/security-options-loader/security-options-loader.service.mjs

@@ -0,0 +1,43 @@
+/*!
+ * @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 { AppConfigService, AppConfigValues } from '@alfresco/adf-core';
+import { AdfHttpClient } from '@alfresco/adf-core/api';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "@alfresco/adf-core/api";
+export class SecurityOptionsLoaderService {
+    constructor(appConfigService, adfHttpClient) {
+        this.appConfigService = appConfigService;
+        this.adfHttpClient = adfHttpClient;
+        this.load = () => {
+            const withCredentials = this.appConfigService.get(AppConfigValues.AUTH_WITH_CREDENTIALS);
+            if (withCredentials !== undefined && withCredentials !== null) {
+                this.adfHttpClient.setDefaultSecurityOption({ withCredentials });
+            }
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SecurityOptionsLoaderService, deps: [{ token: i1.AppConfigService }, { token: i2.AdfHttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SecurityOptionsLoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SecurityOptionsLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: i2.AdfHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/alfresco-api.interface.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxmcmVzY28tYXBpLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvc2VydmljZXMvYWxmcmVzY28tYXBpLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUciLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7IEFsZnJlc2NvQXBpQ29uZmlnLCBBbGZyZXNjb0FwaSB9IGZyb20gJ0BhbGZyZXNjby9qcy1hcGknO1xuXG5leHBvcnQgaW50ZXJmYWNlIEFsZnJlc2NvQXBpSW50ZXJmYWNlIHtcbiAgICBsb2FkKCk6IFByb21pc2U8dm9pZD4gO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEFsZnJlc2NvQXBpRmFjdG9yeSB7XG4gICAgY3JlYXRlQWxmcmVzY29BcGkoY29uZmlnOiBBbGZyZXNjb0FwaUNvbmZpZyk6IEFsZnJlc2NvQXBpO1xufVxuIl19

package/esm2022/lib/services/alfresco-api.service.mjs

@@ -0,0 +1,120 @@
+/*!
+ * @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 { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { AlfrescoApi, AlfrescoApiConfig } from '@alfresco/js-api';
+import { ReplaySubject } from 'rxjs';
+import { AppConfigService, AppConfigValues, StorageService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+export const ALFRESCO_API_FACTORY = new InjectionToken('ALFRESCO_API_FACTORY');
+export class AlfrescoApiService {
+    getInstance() {
+        return this.alfrescoApi;
+    }
+    constructor(appConfig, storageService, alfrescoApiFactory) {
+        this.appConfig = appConfig;
+        this.storageService = storageService;
+        this.alfrescoApiFactory = alfrescoApiFactory;
+        this.alfrescoApiInitialized = new ReplaySubject(1);
+        this.excludedErrorUrl = ['api/enterprise/system/properties'];
+    }
+    async load(config) {
+        this.currentAppConfig = config;
+        if (config.authType === 'OAUTH') {
+            await this.mapAlfrescoApiOpenIdConfig();
+        }
+        this.initAlfrescoApi();
+        this.alfrescoApiInitialized.next(true);
+    }
+    async reset() {
+        this.getCurrentAppConfig();
+        if (this.currentAppConfig.authType === 'OAUTH') {
+            await this.mapAlfrescoApiOpenIdConfig();
+        }
+        this.initAlfrescoApiWithConfig();
+    }
+    getAuthWithFixedOriginLocation() {
+        const oauth = this.appConfig.oauth2;
+        if (oauth) {
+            oauth.redirectUri = window.location.origin + window.location.pathname;
+            oauth.redirectUriLogout = window.location.origin + window.location.pathname;
+        }
+        return oauth;
+    }
+    async mapAlfrescoApiOpenIdConfig() {
+        this.idpConfig = await this.appConfig.loadWellKnown(this.currentAppConfig.oauth2.host);
+        this.currentAppConfig.oauth2.tokenUrl = this.idpConfig.token_endpoint;
+        this.currentAppConfig.oauth2.authorizationUrl = this.idpConfig.authorization_endpoint;
+        this.currentAppConfig.oauth2.logoutUrl = this.idpConfig.end_session_endpoint;
+        this.currentAppConfig.oauth2.userinfoEndpoint = this.idpConfig.userinfo_endpoint;
+    }
+    getCurrentAppConfig() {
+        const oauth = this.getAuthWithFixedOriginLocation();
+        this.currentAppConfig = new AlfrescoApiConfig({
+            provider: this.appConfig.get(AppConfigValues.PROVIDERS),
+            hostEcm: this.appConfig.get(AppConfigValues.ECMHOST),
+            hostBpm: this.appConfig.get(AppConfigValues.BPMHOST),
+            authType: this.appConfig.get(AppConfigValues.AUTHTYPE, 'BASIC'),
+            contextRootBpm: this.appConfig.get(AppConfigValues.CONTEXTROOTBPM),
+            contextRoot: this.appConfig.get(AppConfigValues.CONTEXTROOTECM),
+            disableCsrf: this.appConfig.get(AppConfigValues.DISABLECSRF),
+            withCredentials: this.appConfig.get(AppConfigValues.AUTH_WITH_CREDENTIALS, false),
+            domainPrefix: this.appConfig.get(AppConfigValues.STORAGE_PREFIX),
+            oauth2: oauth
+        });
+    }
+    initAlfrescoApi() {
+        this.getCurrentAppConfig();
+        this.initAlfrescoApiWithConfig();
+    }
+    initAlfrescoApiWithConfig() {
+        if (this.alfrescoApi && this.isDifferentConfig(this.lastConfig, this.currentAppConfig)) {
+            this.alfrescoApi.setConfig(this.currentAppConfig);
+        }
+        else {
+            this.alfrescoApi = this.createInstance(this.currentAppConfig);
+        }
+        this.lastConfig = this.currentAppConfig;
+    }
+    createInstance(config) {
+        if (this.alfrescoApiFactory) {
+            return this.alfrescoApiFactory.createAlfrescoApi(config);
+        }
+        return new AlfrescoApi(config);
+    }
+    isDifferentConfig(lastConfig, newConfig) {
+        return JSON.stringify(lastConfig) !== JSON.stringify(newConfig);
+    }
+    isExcludedErrorListener(currentFullPath) {
+        const formattedPath = currentFullPath.replace(this.lastConfig.hostBpm + '/' + this.lastConfig.contextRootBpm, '');
+        return this.excludedErrorUrl.includes(formattedPath);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AlfrescoApiService, deps: [{ token: i1.AppConfigService }, { token: i1.StorageService }, { token: ALFRESCO_API_FACTORY, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AlfrescoApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AlfrescoApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: i1.StorageService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ALFRESCO_API_FACTORY]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alfresco-api.service.js","sourceRoot":"","sources":["../../../../../../lib/content-services/src/lib/services/alfresco-api.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 { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport { AlfrescoApi, AlfrescoApiConfig } from '@alfresco/js-api';\nimport { ReplaySubject } from 'rxjs';\nimport { AlfrescoApiFactory } from './alfresco-api.interface';\nimport { AppConfigService, AppConfigValues, OauthConfigModel, OpenidConfiguration, StorageService } from '@alfresco/adf-core';\n\nexport const ALFRESCO_API_FACTORY = new InjectionToken('ALFRESCO_API_FACTORY');\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class AlfrescoApiService {\n    alfrescoApiInitialized = new ReplaySubject<boolean>(1);\n\n    protected alfrescoApi: AlfrescoApi;\n\n    lastConfig: AlfrescoApiConfig;\n    currentAppConfig: AlfrescoApiConfig;\n\n    idpConfig: OpenidConfiguration;\n\n    private excludedErrorUrl: string[] = ['api/enterprise/system/properties'];\n\n    getInstance(): AlfrescoApi {\n        return this.alfrescoApi;\n    }\n\n    constructor(\n        protected appConfig: AppConfigService,\n        protected storageService: StorageService,\n        @Optional()\n        @Inject(ALFRESCO_API_FACTORY)\n        private alfrescoApiFactory?: AlfrescoApiFactory\n    ) {}\n\n    async load(config: AlfrescoApiConfig): Promise<void> {\n        this.currentAppConfig = config;\n\n        if (config.authType === 'OAUTH') {\n            await this.mapAlfrescoApiOpenIdConfig();\n        }\n\n        this.initAlfrescoApi();\n        this.alfrescoApiInitialized.next(true);\n    }\n\n    async reset() {\n        this.getCurrentAppConfig();\n        if (this.currentAppConfig.authType === 'OAUTH') {\n            await this.mapAlfrescoApiOpenIdConfig();\n        }\n        this.initAlfrescoApiWithConfig();\n    }\n\n    private getAuthWithFixedOriginLocation(): OauthConfigModel {\n        const oauth = this.appConfig.oauth2;\n\n        if (oauth) {\n            oauth.redirectUri = window.location.origin + window.location.pathname;\n            oauth.redirectUriLogout = window.location.origin + window.location.pathname;\n        }\n        return oauth;\n    }\n\n    private async mapAlfrescoApiOpenIdConfig() {\n        this.idpConfig = await this.appConfig.loadWellKnown(this.currentAppConfig.oauth2.host);\n        this.currentAppConfig.oauth2.tokenUrl = this.idpConfig.token_endpoint;\n        this.currentAppConfig.oauth2.authorizationUrl = this.idpConfig.authorization_endpoint;\n        this.currentAppConfig.oauth2.logoutUrl = this.idpConfig.end_session_endpoint;\n        this.currentAppConfig.oauth2.userinfoEndpoint = this.idpConfig.userinfo_endpoint;\n    }\n\n    private getCurrentAppConfig() {\n        const oauth = this.getAuthWithFixedOriginLocation();\n\n        this.currentAppConfig = new AlfrescoApiConfig({\n            provider: this.appConfig.get<string>(AppConfigValues.PROVIDERS),\n            hostEcm: this.appConfig.get<string>(AppConfigValues.ECMHOST),\n            hostBpm: this.appConfig.get<string>(AppConfigValues.BPMHOST),\n            authType: this.appConfig.get<string>(AppConfigValues.AUTHTYPE, 'BASIC'),\n            contextRootBpm: this.appConfig.get<string>(AppConfigValues.CONTEXTROOTBPM),\n            contextRoot: this.appConfig.get<string>(AppConfigValues.CONTEXTROOTECM),\n            disableCsrf: this.appConfig.get<boolean>(AppConfigValues.DISABLECSRF),\n            withCredentials: this.appConfig.get<boolean>(AppConfigValues.AUTH_WITH_CREDENTIALS, false),\n            domainPrefix: this.appConfig.get<string>(AppConfigValues.STORAGE_PREFIX),\n            oauth2: oauth\n        });\n    }\n\n    protected initAlfrescoApi() {\n        this.getCurrentAppConfig();\n        this.initAlfrescoApiWithConfig();\n    }\n\n    private initAlfrescoApiWithConfig() {\n        if (this.alfrescoApi && this.isDifferentConfig(this.lastConfig, this.currentAppConfig)) {\n            this.alfrescoApi.setConfig(this.currentAppConfig);\n        } else {\n            this.alfrescoApi = this.createInstance(this.currentAppConfig);\n        }\n        this.lastConfig = this.currentAppConfig;\n    }\n\n    createInstance(config: AlfrescoApiConfig): AlfrescoApi {\n        if (this.alfrescoApiFactory) {\n            return this.alfrescoApiFactory.createAlfrescoApi(config);\n        }\n        return new AlfrescoApi(config);\n    }\n\n    isDifferentConfig(lastConfig: AlfrescoApiConfig, newConfig: AlfrescoApiConfig) {\n        return JSON.stringify(lastConfig) !== JSON.stringify(newConfig);\n    }\n\n    isExcludedErrorListener(currentFullPath: string): boolean {\n        const formattedPath = currentFullPath.replace(this.lastConfig.hostBpm + '/' + this.lastConfig.contextRootBpm, '');\n        return this.excludedErrorUrl.includes(formattedPath);\n    }\n}\n"]}

package/esm2022/lib/services/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/lib/services/public-api.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 './alfresco-api.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvc2VydmljZXMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2FsZnJlc2NvLWFwaS5zZXJ2aWNlJztcbmV4cG9ydCB7IEFsZnJlc2NvQXBpRmFjdG9yeSB9IGZyb20gJy4vYWxmcmVzY28tYXBpLmludGVyZmFjZSc7XG4iXX0=

package/esm2022/lib/tag/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3RhZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/lib/tag/public-api.mjs

@@ -0,0 +1,24 @@
+/*!
+ * @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 './tag-actions/tag-actions.component';
+export * from './tag-list/tag-list.component';
+export * from './tag-node-list/tag-node-list.component';
+export * from './services/tag.service';
+export * from './tag.module';
+export * from './tags-creator/tags-creator-mode';
+export * from './tags-creator/tags-creator.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvdGFnL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMseUNBQXlDLENBQUM7QUFFeEQsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxjQUFjLGNBQWMsQ0FBQztBQUU3QixjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsdUNBQXVDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vdGFnLWFjdGlvbnMvdGFnLWFjdGlvbnMuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vdGFnLWxpc3QvdGFnLWxpc3QuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vdGFnLW5vZGUtbGlzdC90YWctbm9kZS1saXN0LmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvdGFnLnNlcnZpY2UnO1xuXG5leHBvcnQgKiBmcm9tICcuL3RhZy5tb2R1bGUnO1xuXG5leHBvcnQgKiBmcm9tICcuL3RhZ3MtY3JlYXRvci90YWdzLWNyZWF0b3ItbW9kZSc7XG5leHBvcnQgKiBmcm9tICcuL3RhZ3MtY3JlYXRvci90YWdzLWNyZWF0b3IuY29tcG9uZW50JztcbiJdfQ==