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

package/esm2022/lib/search/services/search-header-query-builder.service.mjs

@@ -0,0 +1,136 @@
+/*!
+ * @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 { AppConfigService } from '@alfresco/adf-core';
+import { BaseQueryBuilderService } from './base-query-builder.service';
+import { filter } from 'rxjs/operators';
+import { NodesApiService } from '../../common/services/nodes-api.service';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "../../services/alfresco-api.service";
+import * as i3 from "../../common/services/nodes-api.service";
+export class SearchHeaderQueryBuilderService extends BaseQueryBuilderService {
+    constructor(appConfig, alfrescoApiService, nodeApiService) {
+        super(appConfig, alfrescoApiService);
+        this.nodeApiService = nodeApiService;
+        this.customSources = ['-trashcan-', '-sharedlinks-', '-sites-', '-mysites-', '-favorites-', '-recent-', '-my-'];
+        this.activeFilters = [];
+        this.updated.pipe(filter((query) => !!query)).subscribe(() => {
+            this.execute();
+        });
+    }
+    isFilterServiceActive() {
+        return true;
+    }
+    loadConfiguration() {
+        return this.appConfig.get('search-headers');
+    }
+    setupCurrentPagination(maxItems, skipCount) {
+        if (!this.paging || (this.paging && this.paging.maxItems !== maxItems) || this.paging.skipCount !== skipCount) {
+            this.paging = { maxItems, skipCount };
+            this.execute();
+        }
+    }
+    setActiveFilter(columnActivated, filterValue) {
+        const selectedFilter = this.activeFilters.find((activeFilter) => activeFilter.key === columnActivated);
+        if (!selectedFilter) {
+            this.activeFilters.push({
+                key: columnActivated,
+                value: filterValue
+            });
+        }
+        else {
+            selectedFilter.value = filterValue;
+        }
+    }
+    resetActiveFilters() {
+        this.activeFilters = [];
+    }
+    getActiveFilters() {
+        return this.activeFilters;
+    }
+    isNoFilterActive() {
+        return this.activeFilters.length === 0;
+    }
+    removeActiveFilter(columnRemoved) {
+        const filterIndex = this.activeFilters.map((activeFilter) => activeFilter.key).indexOf(columnRemoved);
+        if (filterIndex >= 0) {
+            this.activeFilters.splice(filterIndex, 1);
+        }
+    }
+    setSorting(dataSorting) {
+        this.sorting = [];
+        dataSorting.forEach((columnSorting) => {
+            const fieldValue = this.getSortingFieldFromColumnName(columnSorting.key);
+            if (fieldValue) {
+                const optionAscending = columnSorting.direction.toLocaleLowerCase() === 'asc';
+                const type = fieldValue === 'score' ? 'SCORE' : 'FIELD';
+                const currentSort = {
+                    key: columnSorting.key,
+                    label: 'current',
+                    type,
+                    field: fieldValue,
+                    ascending: optionAscending
+                };
+                this.sorting.push(currentSort);
+            }
+        });
+        this.execute();
+    }
+    getSortingFieldFromColumnName(columnName) {
+        if (this.sortingOptions.length > 0) {
+            const sortOption = this.sortingOptions.find((option) => option.key === columnName);
+            return sortOption ? sortOption.field : '';
+        }
+        return '';
+    }
+    getCategoryForColumn(columnKey) {
+        let foundCategory = null;
+        if (this.categories !== null) {
+            foundCategory = this.categories.find((category) => category.columnKey === columnKey);
+        }
+        return foundCategory;
+    }
+    setCurrentRootFolderId(currentFolderId) {
+        const alreadyAddedFilter = this.filterQueries.find((filterQueries) => filterQueries.query.includes(currentFolderId));
+        if (alreadyAddedFilter !== undefined) {
+            this.filterQueries = [];
+        }
+        this.filterQueries = [
+            {
+                query: `PARENT:"workspace://SpacesStore/${currentFolderId}"`
+            }
+        ];
+        this.execute();
+    }
+    isCustomSourceNode(currentNodeId) {
+        return this.customSources.includes(currentNodeId);
+    }
+    getNodeIdForCustomSource(customSourceId) {
+        return this.nodeApiService.getNode(customSourceId);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchHeaderQueryBuilderService, deps: [{ token: i1.AppConfigService }, { token: i2.AlfrescoApiService }, { token: i3.NodesApiService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchHeaderQueryBuilderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchHeaderQueryBuilderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: i2.AlfrescoApiService }, { type: i3.NodesApiService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-header-query-builder.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/search/services/search-header-query-builder.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 { AppConfigService, DataSorting } from '@alfresco/adf-core';\nimport { SearchConfiguration } from '../models/search-configuration.interface';\nimport { BaseQueryBuilderService } from './base-query-builder.service';\nimport { SearchCategory } from '../models/search-category.interface';\nimport { Node } from '@alfresco/js-api';\nimport { filter } from 'rxjs/operators';\nimport { Observable } from 'rxjs';\nimport { SearchSortingDefinition } from '../models/search-sorting-definition.interface';\nimport { FilterSearch } from '../models/filter-search.interface';\nimport { NodesApiService } from '../../common/services/nodes-api.service';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class SearchHeaderQueryBuilderService extends BaseQueryBuilderService {\n    private customSources = ['-trashcan-', '-sharedlinks-', '-sites-', '-mysites-', '-favorites-', '-recent-', '-my-'];\n\n    activeFilters: FilterSearch[] = [];\n\n    constructor(appConfig: AppConfigService, alfrescoApiService: AlfrescoApiService, private nodeApiService: NodesApiService) {\n        super(appConfig, alfrescoApiService);\n\n        this.updated.pipe(filter((query) => !!query)).subscribe(() => {\n            this.execute();\n        });\n    }\n\n    public isFilterServiceActive(): boolean {\n        return true;\n    }\n\n    loadConfiguration(): SearchConfiguration {\n        return this.appConfig.get<SearchConfiguration>('search-headers');\n    }\n\n    setupCurrentPagination(maxItems: number, skipCount: number) {\n        if (!this.paging || (this.paging && this.paging.maxItems !== maxItems) || this.paging.skipCount !== skipCount) {\n            this.paging = { maxItems, skipCount };\n            this.execute();\n        }\n    }\n\n    setActiveFilter(columnActivated: string, filterValue: string) {\n        const selectedFilter = this.activeFilters.find((activeFilter) => activeFilter.key === columnActivated);\n        if (!selectedFilter) {\n            this.activeFilters.push({\n                key: columnActivated,\n                value: filterValue\n            });\n        } else {\n            selectedFilter.value = filterValue;\n        }\n    }\n\n    resetActiveFilters() {\n        this.activeFilters = [];\n    }\n\n    getActiveFilters(): FilterSearch[] {\n        return this.activeFilters;\n    }\n\n    isNoFilterActive(): boolean {\n        return this.activeFilters.length === 0;\n    }\n\n    removeActiveFilter(columnRemoved: string) {\n        const filterIndex = this.activeFilters.map((activeFilter) => activeFilter.key).indexOf(columnRemoved);\n        if (filterIndex >= 0) {\n            this.activeFilters.splice(filterIndex, 1);\n        }\n    }\n\n    setSorting(dataSorting: DataSorting[]) {\n        this.sorting = [];\n        dataSorting.forEach((columnSorting: DataSorting) => {\n            const fieldValue = this.getSortingFieldFromColumnName(columnSorting.key);\n            if (fieldValue) {\n                const optionAscending = columnSorting.direction.toLocaleLowerCase() === 'asc';\n                const type = fieldValue === 'score' ? 'SCORE' : 'FIELD';\n                const currentSort: SearchSortingDefinition = {\n                    key: columnSorting.key,\n                    label: 'current',\n                    type,\n                    field: fieldValue,\n                    ascending: optionAscending\n                };\n                this.sorting.push(currentSort);\n            }\n        });\n\n        this.execute();\n    }\n\n    private getSortingFieldFromColumnName(columnName: string) {\n        if (this.sortingOptions.length > 0) {\n            const sortOption = this.sortingOptions.find((option) => option.key === columnName);\n            return sortOption ? sortOption.field : '';\n        }\n        return '';\n    }\n\n    getCategoryForColumn(columnKey: string): SearchCategory {\n        let foundCategory = null;\n        if (this.categories !== null) {\n            foundCategory = this.categories.find((category) => category.columnKey === columnKey);\n        }\n        return foundCategory;\n    }\n\n    setCurrentRootFolderId(currentFolderId: string) {\n        const alreadyAddedFilter = this.filterQueries.find((filterQueries) => filterQueries.query.includes(currentFolderId));\n\n        if (alreadyAddedFilter !== undefined) {\n            this.filterQueries = [];\n        }\n\n        this.filterQueries = [\n            {\n                query: `PARENT:\"workspace://SpacesStore/${currentFolderId}\"`\n            }\n        ];\n\n        this.execute();\n    }\n\n    isCustomSourceNode(currentNodeId: string): boolean {\n        return this.customSources.includes(currentNodeId);\n    }\n\n    getNodeIdForCustomSource(customSourceId: string): Observable<Node> {\n        return this.nodeApiService.getNode(customSourceId);\n    }\n}\n"]}

package/esm2022/lib/search/services/search-query-builder.service.mjs

@@ -0,0 +1,48 @@
+/*!
+ * @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, Optional } from '@angular/core';
+import { AppConfigService } from '@alfresco/adf-core';
+import { BaseQueryBuilderService } from './base-query-builder.service';
+import { ADF_SEARCH_CONFIGURATION } from '../search-configuration.token';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "../../services/alfresco-api.service";
+export class SearchQueryBuilderService extends BaseQueryBuilderService {
+    isFilterServiceActive() {
+        return false;
+    }
+    constructor(appConfig, alfrescoApiService, configuration) {
+        super(appConfig, alfrescoApiService);
+        this.configuration = configuration;
+    }
+    loadConfiguration() {
+        return this.configuration || this.appConfig.get('search');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchQueryBuilderService, deps: [{ token: i1.AppConfigService }, { token: i2.AlfrescoApiService }, { token: ADF_SEARCH_CONFIGURATION, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchQueryBuilderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchQueryBuilderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: i2.AlfrescoApiService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ADF_SEARCH_CONFIGURATION]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/services/search.service.mjs

@@ -0,0 +1,89 @@
+/*!
+ * @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 } from '@angular/core';
+import { QueriesApi, SearchApi } from '@alfresco/js-api';
+import { Subject, from } from 'rxjs';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import { SearchConfigurationService } from './search-configuration.service';
+import * as i0 from "@angular/core";
+export class SearchService {
+    constructor() {
+        this.apiService = inject(AlfrescoApiService);
+        this.searchConfigurationService = inject(SearchConfigurationService);
+        this.dataLoaded = new Subject();
+    }
+    get queriesApi() {
+        this._queriesApi = this._queriesApi ?? new QueriesApi(this.apiService.getInstance());
+        return this._queriesApi;
+    }
+    get searchApi() {
+        this._searchApi = this._searchApi ?? new SearchApi(this.apiService.getInstance());
+        return this._searchApi;
+    }
+    /**
+     * Gets a list of nodes that match the given search criteria.
+     *
+     * @param term Term to search for
+     * @param options Options for delivery of the search results
+     * @returns List of nodes resulting from the search
+     */
+    getNodeQueryResults(term, options) {
+        const promise = this.queriesApi.findNodes(term, options);
+        promise.then((nodePaging) => {
+            this.dataLoaded.next(nodePaging);
+        });
+        return from(promise);
+    }
+    /**
+     * Performs a search.
+     *
+     * @param searchTerm Term to search for
+     * @param maxResults Maximum number of items in the list of results
+     * @param skipCount Number of higher-ranked items to skip over in the list
+     * @returns List of search results
+     */
+    search(searchTerm, maxResults, skipCount) {
+        const searchQuery = this.searchConfigurationService.generateQueryBody(searchTerm, maxResults, skipCount);
+        const promise = this.searchApi.search(searchQuery);
+        promise.then((nodePaging) => {
+            this.dataLoaded.next(nodePaging);
+        });
+        return from(promise);
+    }
+    /**
+     * Performs a search with its parameters supplied by a request object.
+     *
+     * @param queryBody Object containing the search parameters
+     * @returns List of search results
+     */
+    searchByQueryBody(queryBody) {
+        const promise = this.searchApi.search(queryBody);
+        promise.then((nodePaging) => {
+            this.dataLoaded.next(nodePaging);
+        });
+        return from(promise);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/search/services/search.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAc,UAAU,EAAkC,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACrG,OAAO,EAAc,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;;AAK5E,MAAM,OAAO,aAAa;IAH1B;QAIY,eAAU,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAC;QACxC,+BAA0B,GAAG,MAAM,CAAC,0BAA0B,CAAC,CAAC;QAExE,eAAU,GAAG,IAAI,OAAO,EAAmB,CAAC;KAiE/C;IA9DG,IAAI,UAAU;QACV,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,IAAI,IAAI,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC;QACrF,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAGD,IAAI,SAAS;QACT,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC;QAClF,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED;;;;;;OAMG;IACH,mBAAmB,CAAC,IAAY,EAAE,OAAuB;QACrD,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAEzD,OAAO,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE;YACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,UAAkB,EAAE,UAAkB,EAAE,SAAiB;QAC5D,MAAM,WAAW,GAAG,IAAI,CAAC,0BAA0B,CAAC,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;QACzG,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAEnD,OAAO,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE;YACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC;IAED;;;;;OAKG;IACH,iBAAiB,CAAC,SAAwB;QACtC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAEjD,OAAO,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE;YACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC;+GApEQ,aAAa;mHAAb,aAAa,cAFV,MAAM;;4FAET,aAAa;kBAHzB,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","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 } from '@angular/core';\nimport { NodePaging, QueriesApi, SearchRequest, ResultSetPaging, SearchApi } from '@alfresco/js-api';\nimport { Observable, Subject, from } from 'rxjs';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\nimport { SearchConfigurationService } from './search-configuration.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class SearchService {\n    private apiService = inject(AlfrescoApiService);\n    private searchConfigurationService = inject(SearchConfigurationService);\n\n    dataLoaded = new Subject<ResultSetPaging>();\n\n    private _queriesApi: QueriesApi;\n    get queriesApi(): QueriesApi {\n        this._queriesApi = this._queriesApi ?? new QueriesApi(this.apiService.getInstance());\n        return this._queriesApi;\n    }\n\n    private _searchApi: SearchApi;\n    get searchApi(): SearchApi {\n        this._searchApi = this._searchApi ?? new SearchApi(this.apiService.getInstance());\n        return this._searchApi;\n    }\n\n    /**\n     * Gets a list of nodes that match the given search criteria.\n     *\n     * @param term Term to search for\n     * @param options Options for delivery of the search results\n     * @returns List of nodes resulting from the search\n     */\n    getNodeQueryResults(term: string, options?: SearchOptions): Observable<NodePaging> {\n        const promise = this.queriesApi.findNodes(term, options);\n\n        promise.then((nodePaging) => {\n            this.dataLoaded.next(nodePaging);\n        });\n\n        return from(promise);\n    }\n\n    /**\n     * Performs a search.\n     *\n     * @param searchTerm Term to search for\n     * @param maxResults Maximum number of items in the list of results\n     * @param skipCount Number of higher-ranked items to skip over in the list\n     * @returns List of search results\n     */\n    search(searchTerm: string, maxResults: number, skipCount: number): Observable<ResultSetPaging> {\n        const searchQuery = this.searchConfigurationService.generateQueryBody(searchTerm, maxResults, skipCount);\n        const promise = this.searchApi.search(searchQuery);\n\n        promise.then((nodePaging) => {\n            this.dataLoaded.next(nodePaging);\n        });\n\n        return from(promise);\n    }\n\n    /**\n     * Performs a search with its parameters supplied by a request object.\n     *\n     * @param queryBody Object containing the search parameters\n     * @returns List of search results\n     */\n    searchByQueryBody(queryBody: SearchRequest): Observable<ResultSetPaging> {\n        const promise = this.searchApi.search(queryBody);\n\n        promise.then((nodePaging) => {\n            this.dataLoaded.next(nodePaging);\n        });\n\n        return from(promise);\n    }\n}\n\nexport interface SearchOptions {\n    /** The number of entities that exist in the collection before those included in this list. */\n    skipCount?: number;\n\n    /** The maximum number of items to return in the list. */\n    maxItems?: number;\n\n    /** The id of the node to start the search from. Supports the aliases -my-, -root- and -shared-. */\n    rootNodeId?: string;\n\n    /** Restrict the returned results to only those of the given node type and its sub-types. */\n    nodeType?: string;\n\n    /**\n     * Return additional information about the node. The available optional fields are:\n     * `allowableOperations`, `aspectNames`, `isLink`, `isLocked`, `path` and `properties`.\n     */\n    include?: string[];\n\n    /**\n     * String array to control the order of the entities returned in a list. You can use this\n     * parameter to sort the list by one or more fields. Each field has a default sort order,\n     * which is normally ascending order (but see the JS-API docs to check if any fields used\n     * in a method have a descending default search order). To sort the entities in a specific\n     * order, you can use the \"ASC\" and \"DESC\" keywords for any field.\n     */\n    orderBy?: string[];\n\n    /**\n     * List of field names. You can use this parameter to restrict the fields returned within\n     * a response if, for example, you want to save on overall bandwidth. The list applies to a\n     * returned individual entity or entries within a collection. If the API method also supports\n     * the `include` parameter, then the fields specified in the include parameter are returned in\n     * addition to those specified in the fields parameter.\n     */\n    fields?: string[];\n}\n"]}

package/esm2022/lib/search-ai/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlYXJjaC1haS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/lib/search-ai/models/search-ai-input-state.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLWFpLWlucHV0LXN0YXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2NvbnRlbnQtc2VydmljZXMvc3JjL2xpYi9zZWFyY2gtYWkvbW9kZWxzL3NlYXJjaC1haS1pbnB1dC1zdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUciLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCBpbnRlcmZhY2UgU2VhcmNoQWlJbnB1dFN0YXRlIHtcbiAgICBhY3RpdmU6IGJvb2xlYW47XG4gICAgc2VsZWN0ZWRBZ2VudElkPzogc3RyaW5nO1xuICAgIHNlYXJjaFRlcm0/OiBzdHJpbmc7XG59XG4iXX0=

package/esm2022/lib/search-ai/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 './services/search-ai.service';
+export * from './models/search-ai-input-state';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvc2VhcmNoLWFpL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLGdDQUFnQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3NlYXJjaC1haS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3NlYXJjaC1haS1pbnB1dC1zdGF0ZSc7XG4iXX0=

package/esm2022/lib/search-ai/services/search-ai.service.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 { Injectable } from '@angular/core';
+import { SearchAiApi } from '@alfresco/js-api';
+import { BehaviorSubject, from } from 'rxjs';
+import { TranslateService } from '@ngx-translate/core';
+import { AlfrescoApiService } from '../../services';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services";
+import * as i2 from "@ngx-translate/core";
+export class SearchAiService {
+    get searchAiApi() {
+        this._searchAiApi = this._searchAiApi ?? new SearchAiApi(this.apiService.getInstance());
+        return this._searchAiApi;
+    }
+    constructor(apiService, translateService) {
+        this.apiService = apiService;
+        this.translateService = translateService;
+        this.toggleSearchAiInput = new BehaviorSubject({
+            active: false
+        });
+        this.toggleSearchAiInput$ = this.toggleSearchAiInput.asObservable();
+    }
+    /**
+     * Update the state of the search AI input.
+     *
+     * @param state The new state of the search AI input.
+     */
+    updateSearchAiInputState(state) {
+        this.toggleSearchAiInput.next(state);
+    }
+    /**
+     * Ask a question to the AI.
+     *
+     * @param question The question to ask.
+     * @returns QuestionModel object containing information about questions.
+     */
+    ask(question) {
+        return from(this.searchAiApi.ask([question]));
+    }
+    /**
+     * Get an answer to specific question.
+     *
+     * @param questionId The ID of the question to get an answer for.
+     * @returns AiAnswerEntry object containing the answer.
+     */
+    getAnswer(questionId) {
+        return from(this.searchAiApi.getAnswer(questionId));
+    }
+    /**
+     * Get the knowledge retrieval configuration.
+     *
+     * @returns KnowledgeRetrievalConfigEntry object containing the configuration.
+     */
+    getConfig() {
+        return from(this.searchAiApi.getConfig());
+    }
+    /**
+     * Check if using of search is possible (if all conditions are met).
+     *
+     * @param selectedNodesState information about selected nodes.
+     * @param maxSelectedNodes max number of selected nodes. Default 100.
+     * @returns string with error if any condition is not met, empty string otherwise.
+     */
+    checkSearchAvailability(selectedNodesState, maxSelectedNodes = 100) {
+        const messages = [];
+        if (selectedNodesState.count > maxSelectedNodes) {
+            messages.push({
+                key: 'KNOWLEDGE_RETRIEVAL.SEARCH.WARNINGS.TOO_MANY_FILES_SELECTED',
+                maxFiles: maxSelectedNodes
+            });
+        }
+        if (selectedNodesState.nodes.some((node) => node.entry.isFolder)) {
+            messages.push({
+                key: 'KNOWLEDGE_RETRIEVAL.SEARCH.WARNINGS.FOLDER_SELECTED'
+            });
+        }
+        return messages.map((message) => this.translateService.instant(message.key, message)).join(' ');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchAiService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchAiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchAiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-ai.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/search-ai/services/search-ai.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAgF,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC7H,OAAO,EAAE,eAAe,EAAE,IAAI,EAAc,MAAM,MAAM,CAAC;AAEzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;;;;AAKpD,MAAM,OAAO,eAAe;IAMxB,IAAI,WAAW;QACX,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC;QACxF,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAID,YAAoB,UAA8B,EAAU,gBAAkC;QAA1E,eAAU,GAAV,UAAU,CAAoB;QAAU,qBAAgB,GAAhB,gBAAgB,CAAkB;QAZtF,wBAAmB,GAAG,IAAI,eAAe,CAAqB;YAClE,MAAM,EAAE,KAAK;SAChB,CAAC,CAAC;QAQH,yBAAoB,GAAG,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,CAAC;IAEkC,CAAC;IAElG;;;;OAIG;IACH,wBAAwB,CAAC,KAAyB;QAC9C,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAC,QAAyB;QACzB,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAClD,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,UAAkB;QACxB,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;IACxD,CAAC;IAED;;;;OAIG;IACH,SAAS;QACL,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;OAMG;IACH,uBAAuB,CAAC,kBAAkC,EAAE,gBAAgB,GAAG,GAAG;QAC9E,MAAM,QAAQ,GAGR,EAAE,CAAC;QACT,IAAI,kBAAkB,CAAC,KAAK,GAAG,gBAAgB,EAAE,CAAC;YAC9C,QAAQ,CAAC,IAAI,CAAC;gBACV,GAAG,EAAE,6DAA6D;gBAClE,QAAQ,EAAE,gBAAgB;aAC7B,CAAC,CAAC;QACP,CAAC;QACD,IAAI,kBAAkB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC/D,QAAQ,CAAC,IAAI,CAAC;gBACV,GAAG,EAAE,qDAAqD;aAC7D,CAAC,CAAC;QACP,CAAC;QACD,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACpG,CAAC;+GA7EQ,eAAe;mHAAf,eAAe,cAFZ,MAAM;;4FAET,eAAe;kBAH3B,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","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 { AiAnswerEntry, KnowledgeRetrievalConfigEntry, QuestionModel, QuestionRequest, SearchAiApi } from '@alfresco/js-api';\nimport { BehaviorSubject, from, Observable } from 'rxjs';\nimport { SelectionState } from '@alfresco/adf-extensions';\nimport { TranslateService } from '@ngx-translate/core';\nimport { SearchAiInputState } from '../models/search-ai-input-state';\nimport { AlfrescoApiService } from '../../services';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class SearchAiService {\n    private toggleSearchAiInput = new BehaviorSubject<SearchAiInputState>({\n        active: false\n    });\n    private _searchAiApi: SearchAiApi;\n\n    get searchAiApi(): SearchAiApi {\n        this._searchAiApi = this._searchAiApi ?? new SearchAiApi(this.apiService.getInstance());\n        return this._searchAiApi;\n    }\n\n    toggleSearchAiInput$ = this.toggleSearchAiInput.asObservable();\n\n    constructor(private apiService: AlfrescoApiService, private translateService: TranslateService) {}\n\n    /**\n     * Update the state of the search AI input.\n     *\n     * @param state The new state of the search AI input.\n     */\n    updateSearchAiInputState(state: SearchAiInputState): void {\n        this.toggleSearchAiInput.next(state);\n    }\n\n    /**\n     * Ask a question to the AI.\n     *\n     * @param question The question to ask.\n     * @returns QuestionModel object containing information about questions.\n     */\n    ask(question: QuestionRequest): Observable<QuestionModel> {\n        return from(this.searchAiApi.ask([question]));\n    }\n\n    /**\n     * Get an answer to specific question.\n     *\n     * @param questionId The ID of the question to get an answer for.\n     * @returns AiAnswerEntry object containing the answer.\n     */\n    getAnswer(questionId: string): Observable<AiAnswerEntry> {\n        return from(this.searchAiApi.getAnswer(questionId));\n    }\n\n    /**\n     * Get the knowledge retrieval configuration.\n     *\n     * @returns KnowledgeRetrievalConfigEntry object containing the configuration.\n     */\n    getConfig(): Observable<KnowledgeRetrievalConfigEntry> {\n        return from(this.searchAiApi.getConfig());\n    }\n\n    /**\n     * Check if using of search is possible (if all conditions are met).\n     *\n     * @param selectedNodesState information about selected nodes.\n     * @param maxSelectedNodes max number of selected nodes. Default 100.\n     * @returns string with error if any condition is not met, empty string otherwise.\n     */\n    checkSearchAvailability(selectedNodesState: SelectionState, maxSelectedNodes = 100): string {\n        const messages: {\n            key: string;\n            [parameter: string]: number | string;\n        }[] = [];\n        if (selectedNodesState.count > maxSelectedNodes) {\n            messages.push({\n                key: 'KNOWLEDGE_RETRIEVAL.SEARCH.WARNINGS.TOO_MANY_FILES_SELECTED',\n                maxFiles: maxSelectedNodes\n            });\n        }\n        if (selectedNodesState.nodes.some((node) => node.entry.isFolder)) {\n            messages.push({\n                key: 'KNOWLEDGE_RETRIEVAL.SEARCH.WARNINGS.FOLDER_SELECTED'\n            });\n        }\n        return messages.map((message) => this.translateService.instant(message.key, message)).join(' ');\n    }\n}\n"]}

package/esm2022/lib/security/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlY3VyaXR5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/lib/security/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 './services/security-controls-groups-marks-security.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvc2VjdXJpdHkvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLDREQUE0RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3NlY3VyaXR5LWNvbnRyb2xzLWdyb3Vwcy1tYXJrcy1zZWN1cml0eS5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/security/services/models/security-controls-group-response.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjdXJpdHktY29udHJvbHMtZ3JvdXAtcmVzcG9uc2UuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2NvbnRlbnQtc2VydmljZXMvc3JjL2xpYi9zZWN1cml0eS9zZXJ2aWNlcy9tb2RlbHMvc2VjdXJpdHktY29udHJvbHMtZ3JvdXAtcmVzcG9uc2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0IHsgUGFnaW5hdGlvbk1vZGVsIH0gZnJvbSAnQGFsZnJlc2NvL2FkZi1jb3JlJztcbmltcG9ydCB7IFNlY3VyaXR5R3JvdXAgfSBmcm9tICdAYWxmcmVzY28vanMtYXBpJztcblxuZXhwb3J0IGludGVyZmFjZSBTZWN1cml0eUNvbnRyb2xzR3JvdXBSZXNwb25zZSB7XG4gICAgcGFnaW5hdGlvbjogUGFnaW5hdGlvbk1vZGVsO1xuICAgIGVudHJpZXM6IFNlY3VyaXR5R3JvdXBbXTtcbn1cbiJdfQ==

package/esm2022/lib/security/services/models/security-controls-mark-response.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjdXJpdHktY29udHJvbHMtbWFyay1yZXNwb25zZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlY3VyaXR5L3NlcnZpY2VzL21vZGVscy9zZWN1cml0eS1jb250cm9scy1tYXJrLXJlc3BvbnNlLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUciLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7IFBhZ2luYXRpb25Nb2RlbCB9IGZyb20gJ0BhbGZyZXNjby9hZGYtY29yZSc7XG5pbXBvcnQgeyBTZWN1cml0eU1hcmsgfSBmcm9tICdAYWxmcmVzY28vanMtYXBpJztcblxuZXhwb3J0IGludGVyZmFjZSBTZWN1cml0eUNvbnRyb2xzTWFya1Jlc3BvbnNlIHtcbiAgICBwYWdpbmF0aW9uOiBQYWdpbmF0aW9uTW9kZWw7XG4gICAgZW50cmllczogU2VjdXJpdHlNYXJrW107XG59XG4iXX0=