@alfresco/aca-content 5.1.1 → 5.2.0

package/esm2022/lib/services/content-url.service.mjs

@@ -0,0 +1,74 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { getRepositoryStatus } from '@alfresco/aca-shared/store';
+import { take, map, catchError, mergeMap } from 'rxjs/operators';
+import { Store } from '@ngrx/store';
+import { ContentApiService } from '@alfresco/aca-shared';
+import { AlfrescoApiService, ContentVersionService } from '@alfresco/adf-content-services';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@alfresco/aca-shared";
+import * as i3 from "@alfresco/adf-content-services";
+class ContentUrlService extends ContentVersionService {
+    store;
+    contentApiService;
+    constructor(store, contentApiService, alfrescoApiService) {
+        super(alfrescoApiService);
+        this.store = store;
+        this.contentApiService = contentApiService;
+    }
+    getNodeContentUrl(nodeId, attachment = true) {
+        return this.isDirectAccessUrlEnabled().pipe(mergeMap((dauEnabled) => {
+            if (dauEnabled) {
+                return this.contentApiService.requestNodeDirectAccessUrl(nodeId).pipe(map((dauObj) => dauObj.entry.contentUrl), catchError(() => of(this.contentApiService.getContentUrl(nodeId, true))));
+            }
+            else {
+                return of(this.contentApiService.getContentUrl(nodeId, attachment));
+            }
+        }));
+    }
+    getVersionContentUrl(nodeId, versionId, attachment = true) {
+        return this.isDirectAccessUrlEnabled().pipe(mergeMap((dauEnabled) => {
+            if (dauEnabled) {
+                return this.contentApiService.requestVersionDirectAccessUrl(nodeId, versionId).pipe(map((dauObj) => dauObj.entry.contentUrl), catchError(() => of(this.contentApiService.getVersionContentUrl(nodeId, versionId, true))));
+            }
+            else {
+                return of(this.contentApiService.getVersionContentUrl(nodeId, versionId, attachment));
+            }
+        }));
+    }
+    isDirectAccessUrlEnabled() {
+        return this.store.select(getRepositoryStatus).pipe(take(1), map((repository) => !!repository?.status?.isDirectAccessUrlEnabled));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentUrlService, deps: [{ token: i1.Store }, { token: i2.ContentApiService }, { token: i3.AlfrescoApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentUrlService, providedIn: 'root' });
+}
+export { ContentUrlService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentUrlService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.ContentApiService }, { type: i3.AlfrescoApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGVudC11cmwuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FjYS1jb250ZW50L3NyYy9saWIvc2VydmljZXMvY29udGVudC11cmwuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUVILE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFjLEVBQUUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUN0QyxPQUFPLEVBQVksbUJBQW1CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUMzRSxPQUFPLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDakUsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUNwQyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUV6RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQzs7Ozs7QUFFM0YsTUFDYSxpQkFBa0IsU0FBUSxxQkFBcUI7SUFDdEM7SUFBZ0M7SUFBcEQsWUFBb0IsS0FBc0IsRUFBVSxpQkFBb0MsRUFBRSxrQkFBc0M7UUFDOUgsS0FBSyxDQUFDLGtCQUFrQixDQUFDLENBQUM7UUFEUixVQUFLLEdBQUwsS0FBSyxDQUFpQjtRQUFVLHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBbUI7SUFFeEYsQ0FBQztJQUVELGlCQUFpQixDQUFDLE1BQWMsRUFBRSxVQUFVLEdBQUcsSUFBSTtRQUNqRCxPQUFPLElBQUksQ0FBQyx3QkFBd0IsRUFBRSxDQUFDLElBQUksQ0FDekMsUUFBUSxDQUFDLENBQUMsVUFBVSxFQUFFLEVBQUU7WUFDdEIsSUFBSSxVQUFVLEVBQUU7Z0JBQ2QsT0FBTyxJQUFJLENBQUMsaUJBQWlCLENBQUMsMEJBQTBCLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUNuRSxHQUFHLENBQUMsQ0FBQyxNQUE0QixFQUFFLEVBQUUsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxFQUM5RCxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxhQUFhLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FDekUsQ0FBQzthQUNIO2lCQUFNO2dCQUNMLE9BQU8sRUFBRSxDQUFDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxhQUFhLENBQUMsTUFBTSxFQUFFLFVBQVUsQ0FBQyxDQUFDLENBQUM7YUFDckU7UUFDSCxDQUFDLENBQUMsQ0FDSCxDQUFDO0lBQ0osQ0FBQztJQUVELG9CQUFvQixDQUFDLE1BQWMsRUFBRSxTQUFpQixFQUFFLFVBQVUsR0FBRyxJQUFJO1FBQ3ZFLE9BQU8sSUFBSSxDQUFDLHdCQUF3QixFQUFFLENBQUMsSUFBSSxDQUN6QyxRQUFRLENBQUMsQ0FBQyxVQUFVLEVBQUUsRUFBRTtZQUN0QixJQUFJLFVBQVUsRUFBRTtnQkFDZCxPQUFPLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyw2QkFBNkIsQ0FBQyxNQUFNLEVBQUUsU0FBUyxDQUFDLENBQUMsSUFBSSxDQUNqRixHQUFHLENBQUMsQ0FBQyxNQUE0QixFQUFFLEVBQUUsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxFQUM5RCxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxvQkFBb0IsQ0FBQyxNQUFNLEVBQUUsU0FBUyxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FDM0YsQ0FBQzthQUNIO2lCQUFNO2dCQUNMLE9BQU8sRUFBRSxDQUFDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxvQkFBb0IsQ0FBQyxNQUFNLEVBQUUsU0FBUyxFQUFFLFVBQVUsQ0FBQyxDQUFDLENBQUM7YUFDdkY7UUFDSCxDQUFDLENBQUMsQ0FDSCxDQUFDO0lBQ0osQ0FBQztJQUVPLHdCQUF3QjtRQUM5QixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLG1CQUFtQixDQUFDLENBQUMsSUFBSSxDQUNoRCxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQ1AsR0FBRyxDQUFDLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSx3QkFBd0IsQ0FBQyxDQUNwRSxDQUFDO0lBQ0osQ0FBQzt1R0F4Q1UsaUJBQWlCOzJHQUFqQixpQkFBaUIsY0FESixNQUFNOztTQUNuQixpQkFBaUI7MkZBQWpCLGlCQUFpQjtrQkFEN0IsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjQgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb25cbiAqXG4gKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uLlxuICogSWYgdGhlIHNvZnR3YXJlIHdhcyBwdXJjaGFzZWQgdW5kZXIgYSBwYWlkIEFsZnJlc2NvIGxpY2Vuc2UsIHRoZSB0ZXJtcyBvZlxuICogdGhlIHBhaWQgbGljZW5zZSBhZ3JlZW1lbnQgd2lsbCBwcmV2YWlsLiBPdGhlcndpc2UsIHRoZSBzb2Z0d2FyZSBpc1xuICogcHJvdmlkZWQgdW5kZXIgdGhlIGZvbGxvd2luZyBvcGVuIHNvdXJjZSBsaWNlbnNlIHRlcm1zOlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeVxuICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5XG4gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvclxuICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi5cbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsXG4gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZlxuICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlXG4gKiBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy5cbiAqXG4gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2VcbiAqIGZyb20gSHlsYW5kIFNvZnR3YXJlLiBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uXG4gKi9cblxuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgb2YgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IEFwcFN0b3JlLCBnZXRSZXBvc2l0b3J5U3RhdHVzIH0gZnJvbSAnQGFsZnJlc2NvL2FjYS1zaGFyZWQvc3RvcmUnO1xuaW1wb3J0IHsgdGFrZSwgbWFwLCBjYXRjaEVycm9yLCBtZXJnZU1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IFN0b3JlIH0gZnJvbSAnQG5ncngvc3RvcmUnO1xuaW1wb3J0IHsgQ29udGVudEFwaVNlcnZpY2UgfSBmcm9tICdAYWxmcmVzY28vYWNhLXNoYXJlZCc7XG5pbXBvcnQgeyBEaXJlY3RBY2Nlc3NVcmxFbnRyeSB9IGZyb20gJ0BhbGZyZXNjby9qcy1hcGknO1xuaW1wb3J0IHsgQWxmcmVzY29BcGlTZXJ2aWNlLCBDb250ZW50VmVyc2lvblNlcnZpY2UgfSBmcm9tICdAYWxmcmVzY28vYWRmLWNvbnRlbnQtc2VydmljZXMnO1xuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIENvbnRlbnRVcmxTZXJ2aWNlIGV4dGVuZHMgQ29udGVudFZlcnNpb25TZXJ2aWNlIHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBzdG9yZTogU3RvcmU8QXBwU3RvcmU+LCBwcml2YXRlIGNvbnRlbnRBcGlTZXJ2aWNlOiBDb250ZW50QXBpU2VydmljZSwgYWxmcmVzY29BcGlTZXJ2aWNlOiBBbGZyZXNjb0FwaVNlcnZpY2UpIHtcbiAgICBzdXBlcihhbGZyZXNjb0FwaVNlcnZpY2UpO1xuICB9XG5cbiAgZ2V0Tm9kZUNvbnRlbnRVcmwobm9kZUlkOiBzdHJpbmcsIGF0dGFjaG1lbnQgPSB0cnVlKTogT2JzZXJ2YWJsZTxzdHJpbmc+IHtcbiAgICByZXR1cm4gdGhpcy5pc0RpcmVjdEFjY2Vzc1VybEVuYWJsZWQoKS5waXBlKFxuICAgICAgbWVyZ2VNYXAoKGRhdUVuYWJsZWQpID0+IHtcbiAgICAgICAgaWYgKGRhdUVuYWJsZWQpIHtcbiAgICAgICAgICByZXR1cm4gdGhpcy5jb250ZW50QXBpU2VydmljZS5yZXF1ZXN0Tm9kZURpcmVjdEFjY2Vzc1VybChub2RlSWQpLnBpcGUoXG4gICAgICAgICAgICBtYXAoKGRhdU9iajogRGlyZWN0QWNjZXNzVXJsRW50cnkpID0+IGRhdU9iai5lbnRyeS5jb250ZW50VXJsKSxcbiAgICAgICAgICAgIGNhdGNoRXJyb3IoKCkgPT4gb2YodGhpcy5jb250ZW50QXBpU2VydmljZS5nZXRDb250ZW50VXJsKG5vZGVJZCwgdHJ1ZSkpKVxuICAgICAgICAgICk7XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgcmV0dXJuIG9mKHRoaXMuY29udGVudEFwaVNlcnZpY2UuZ2V0Q29udGVudFVybChub2RlSWQsIGF0dGFjaG1lbnQpKTtcbiAgICAgICAgfVxuICAgICAgfSlcbiAgICApO1xuICB9XG5cbiAgZ2V0VmVyc2lvbkNvbnRlbnRVcmwobm9kZUlkOiBzdHJpbmcsIHZlcnNpb25JZDogc3RyaW5nLCBhdHRhY2htZW50ID0gdHJ1ZSk6IE9ic2VydmFibGU8c3RyaW5nPiB7XG4gICAgcmV0dXJuIHRoaXMuaXNEaXJlY3RBY2Nlc3NVcmxFbmFibGVkKCkucGlwZShcbiAgICAgIG1lcmdlTWFwKChkYXVFbmFibGVkKSA9PiB7XG4gICAgICAgIGlmIChkYXVFbmFibGVkKSB7XG4gICAgICAgICAgcmV0dXJuIHRoaXMuY29udGVudEFwaVNlcnZpY2UucmVxdWVzdFZlcnNpb25EaXJlY3RBY2Nlc3NVcmwobm9kZUlkLCB2ZXJzaW9uSWQpLnBpcGUoXG4gICAgICAgICAgICBtYXAoKGRhdU9iajogRGlyZWN0QWNjZXNzVXJsRW50cnkpID0+IGRhdU9iai5lbnRyeS5jb250ZW50VXJsKSxcbiAgICAgICAgICAgIGNhdGNoRXJyb3IoKCkgPT4gb2YodGhpcy5jb250ZW50QXBpU2VydmljZS5nZXRWZXJzaW9uQ29udGVudFVybChub2RlSWQsIHZlcnNpb25JZCwgdHJ1ZSkpKVxuICAgICAgICAgICk7XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgcmV0dXJuIG9mKHRoaXMuY29udGVudEFwaVNlcnZpY2UuZ2V0VmVyc2lvbkNvbnRlbnRVcmwobm9kZUlkLCB2ZXJzaW9uSWQsIGF0dGFjaG1lbnQpKTtcbiAgICAgICAgfVxuICAgICAgfSlcbiAgICApO1xuICB9XG5cbiAgcHJpdmF0ZSBpc0RpcmVjdEFjY2Vzc1VybEVuYWJsZWQoKTogT2JzZXJ2YWJsZTxib29sZWFuPiB7XG4gICAgcmV0dXJuIHRoaXMuc3RvcmUuc2VsZWN0KGdldFJlcG9zaXRvcnlTdGF0dXMpLnBpcGUoXG4gICAgICB0YWtlKDEpLFxuICAgICAgbWFwKChyZXBvc2l0b3J5KSA9PiAhIXJlcG9zaXRvcnk/LnN0YXR1cz8uaXNEaXJlY3RBY2Nlc3NVcmxFbmFibGVkKVxuICAgICk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/services/modal-ai.service.mjs

@@ -0,0 +1,65 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { inject, Injectable } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { AppConfigValues, UnsavedChangesDialogComponent, UserPreferencesService } from '@alfresco/adf-core';
+import { MatDialog } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+class ModalAiService {
+    route = inject(ActivatedRoute);
+    dialog = inject(MatDialog);
+    userPreferencesService = inject(UserPreferencesService);
+    openUnsavedChangesModal(callback) {
+        const hasPreviousSearch = this.route.snapshot?.queryParams?.query?.length > 0;
+        const modalHidden = this.userPreferencesService.get(AppConfigValues.UNSAVED_CHANGES_MODAL_HIDDEN) === 'true';
+        if (!hasPreviousSearch || modalHidden) {
+            callback();
+            return;
+        }
+        this.dialog
+            .open(UnsavedChangesDialogComponent, {
+            width: '345px',
+            data: {
+                descriptionText: 'KNOWLEDGE_RETRIEVAL.SEARCH.DISCARD_CHANGES.LOSE_RESPONSE',
+                confirmButtonText: 'KNOWLEDGE_RETRIEVAL.SEARCH.DISCARD_CHANGES.ASK_AI',
+                checkboxText: 'KNOWLEDGE_RETRIEVAL.SEARCH.DISCARD_CHANGES.DO_NOT_SHOW_MESSAGE',
+                headerText: 'KNOWLEDGE_RETRIEVAL.SEARCH.DISCARD_CHANGES.WARNING'
+            }
+        })
+            .afterClosed()
+            .subscribe((openModal) => {
+            if (openModal) {
+                callback();
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ModalAiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ModalAiService, providedIn: 'root' });
+}
+export { ModalAiService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ModalAiService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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