@sinequa/atomic-angular 0.0.140

package/lib/stores/aggregations.store.d.ts

@@ -0,0 +1,50 @@
+import { Aggregation } from "@sinequa/atomic";
+type AggregationsState = {
+    aggregations: Aggregation[];
+};
+export declare const AggregationsStore: import("@angular/core").Type<{
+    aggregations: import("@angular/core").Signal<Aggregation[]>;
+    update: (aggregations: Aggregation[]) => void;
+    updateAggregation: (aggregation: Aggregation) => void;
+    clear: () => void;
+    getAggregation: (name: string, kind?: "column" | "name") => Aggregation | undefined;
+} & import("@ngrx/signals").StateSignal<{
+    aggregations: Aggregation[];
+}>>;
+export declare function WithAggregationsFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<AggregationsState, "update" | "clear" | "updateAggregation" | "getAggregation">;
+    signals: Omit<{}, "update" | "clear" | "updateAggregation" | "getAggregation">;
+    methods: Omit<{}, "update" | "clear" | "updateAggregation" | "getAggregation">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    methods: {
+        /**
+         * Updates the state with the provided aggregations.
+         *
+         * @param {Aggregation[]} aggregations - The new aggregations to update the state with.
+         */
+        update(aggregations: Aggregation[]): void;
+        /**
+         * Updates an existing aggregation in the store.
+         *
+         * @param aggregation - The aggregation object to update.
+         * @returns void
+         */
+        updateAggregation(aggregation: Aggregation): void;
+        /**
+         * Clears the aggregations in the store by setting the `aggregations` property to an empty array.
+         *
+         * @remarks
+         * This method uses the `patchState` function to update the state of the store.
+         */
+        clear(): void;
+        /**
+         * Retrieves an aggregation by name or column.
+         *
+         * @param name - The name or column of the aggregation to retrieve.
+         * @param kind - The kind of aggregation to retrieve. Defaults to "name".
+         * @returns The matching aggregation, or undefined if not found.
+         */
+        getAggregation(name: string, kind?: "column" | "name"): Aggregation | undefined;
+    };
+}>;
+export {};

package/lib/stores/app.store.d.ts

@@ -0,0 +1,208 @@
+import { InjectionToken } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { Aggregation, CCApp, CCQuery, CCWebService } from '@sinequa/atomic';
+import { CFilter, CFilterItem, CJ, CJson } from '../models/custom-json';
+/**
+ * Injection token for a list of facet names to display in the application.
+ *
+ * This token provides a default list of facet names including:
+ * - Geo
+ * - Company
+ * - Person
+ * - DocFormat
+ * - Modified
+ * - Size
+ * - DocumentLanguages
+ * - Concepts
+ *
+ * @constant
+ * @type {InjectionToken<string[]>}
+ */
+export declare const AGGREGATIONS_NAMES_PRESET_DEFAULT: string[];
+export declare const AGGREGATIONS_NAMES: InjectionToken<string[]>;
+export type CCAppState = {
+    webServices: Record<string, CCWebService>;
+    data: CJson;
+    queries: Record<string, CCQuery>;
+    customJSONs: CJ[];
+};
+export declare const AppStore: import("@angular/core").Type<{
+    webServices: import("@angular/core").Signal<Record<string, CCWebService>>;
+    data: import("@ngrx/signals/src/deep-signal").DeepSignal<CJson>;
+    queries: import("@angular/core").Signal<Record<string, CCQuery>>;
+    customJSONs: import("@angular/core").Signal<CJ[]>;
+    filters: import("@angular/core").Signal<CFilter[]>;
+    sources: import("@angular/core").Signal<import("../models/custom-json").CSources | {
+        routes?: [];
+        filters?: CFilter[];
+    }>;
+    customizationJson: import("@angular/core").Signal<CJson>;
+    update: (app: CCApp) => void;
+    initialize: () => Promise<void>;
+    initializeWithAppName: (appName: string) => Promise<void>;
+    getWebServiceByType: (type: CCWebService["webServiceType"]) => CCWebService | undefined;
+    getLabels: () => {
+        private: string;
+        public: string;
+    };
+    getQueryByName: (name: string) => CCQuery | undefined;
+    getQueryByIndex: (index: number) => CCQuery | undefined;
+    getDefaultQuery: () => CCQuery | undefined;
+    allowEmptySearch: (queryName: string) => boolean;
+    getNamedCustomizationJson: (name: string) => any | undefined;
+    getColumnAlias: (column: string) => string;
+    getAggregationIcon: (column: string) => string | undefined;
+    getAggregationItemsCustomization: (column: string) => CFilterItem[] | undefined;
+    getAggregationCustomization: (column: string) => CFilter | undefined;
+    getAuthorizedFilters: (route: ActivatedRoute) => Aggregation[];
+} & import("@ngrx/signals").StateSignal<{
+    webServices: Record<string, CCWebService>;
+    data: CJson;
+    queries: Record<string, CCQuery>;
+    customJSONs: CJ[];
+}>>;
+/**
+ * Enhances the application store with various features and methods.
+ *
+ * This function integrates state management, computed properties, and methods
+ * to interact with the CCApp state, including initialization, updates,
+ * and retrieval of specific data such as web services, queries, and customization JSONs.
+ *
+ * Features:
+ * - State management with initial data.
+ * - Computed properties for customization JSON, sources, and filters.
+ * - Methods for initializing and updating the application state.
+ * - Methods for retrieving web services, labels, queries, and customization JSONs.
+ * - Methods for retrieving aggregation icons and customization items.
+ *
+ * @returns The enhanced application store with additional features and methods.
+ */
+export declare function withAppFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<Omit<Omit<CCAppState, "filters" | "sources" | "customizationJson">, "update" | "initialize" | "initializeWithAppName" | "getWebServiceByType" | "getLabels" | "getQueryByName" | "getQueryByIndex" | "getDefaultQuery" | "allowEmptySearch" | "getNamedCustomizationJson" | "getColumnAlias">, "getAggregationIcon" | "getAggregationItemsCustomization" | "getAggregationCustomization" | "getAuthorizedFilters">;
+    signals: Omit<Omit<Omit<{}, "filters" | "sources" | "customizationJson"> & {
+        customizationJson: import("@angular/core").Signal<CJson>;
+        sources: import("@angular/core").Signal<import("../models/custom-json").CSources | {
+            routes?: [];
+            filters?: CFilter[];
+        }>;
+        filters: import("@angular/core").Signal<CFilter[]>;
+    }, "update" | "initialize" | "initializeWithAppName" | "getWebServiceByType" | "getLabels" | "getQueryByName" | "getQueryByIndex" | "getDefaultQuery" | "allowEmptySearch" | "getNamedCustomizationJson" | "getColumnAlias">, "getAggregationIcon" | "getAggregationItemsCustomization" | "getAggregationCustomization" | "getAuthorizedFilters">;
+    methods: Omit<Omit<Omit<{}, "filters" | "sources" | "customizationJson">, "update" | "initialize" | "initializeWithAppName" | "getWebServiceByType" | "getLabels" | "getQueryByName" | "getQueryByIndex" | "getDefaultQuery" | "allowEmptySearch" | "getNamedCustomizationJson" | "getColumnAlias"> & {
+        /**
+         * Initializes the application state by fetching the app data from the appService
+         * and updating the store with the retrieved data.
+         *
+         * @returns A promise that resolves when the app data has been fetched and the store has been updated.
+         */
+        initialize(): Promise<void>;
+        /**
+         * Initializes the application state with the provided app name.
+         *
+         * @param appName - The name of the application to fetch the configuration for.
+         *
+         * @returns A promise that resolves when the app data has been fetched and the store has been updated.
+         */
+        initializeWithAppName(appName: string): Promise<void>;
+        /**
+         * Updates the application state with the provided CCApp object.
+         *
+         * @param {CCApp} app - The application object containing the new state values.
+         */
+        update(app: CCApp): void;
+        /**
+         * Returns the web service by type name
+         *
+         * @param type Web service type name
+         * @returns A {@link CCWebService} object or undefined if not found
+         */
+        getWebServiceByType(type: CCWebService["webServiceType"]): CCWebService | undefined;
+        /**
+         * Retrieves the labels from the web service of type 'Labels'.
+         *
+         * @returns An object containing the private and public labels.
+         *          If the labels are not found, returns an object with empty strings for both fields.
+         */
+        getLabels(): {
+            private: string;
+            public: string;
+        };
+        /**
+         * Retrieves a query by its name from the store.
+         *
+         * @param name - The name of the query to retrieve.
+         * @returns The query object if found, otherwise `undefined`.
+         */
+        getQueryByName(name: string): CCQuery | undefined;
+        /**
+         * Retrieves a query by its index from the store.
+         *
+         * @param index - The index of the query to retrieve.
+         * @returns The query at the specified index, or `undefined` if the index is out of bounds.
+         */
+        getQueryByIndex(index: number): CCQuery | undefined;
+        /**
+         * Retrieves the default query.
+         * The default query is always the first query in the list of queries.
+         *
+         * @returns {CCQuery | undefined} The default query if it exists, otherwise undefined.
+         */
+        getDefaultQuery(): CCQuery | undefined;
+        /**
+         * Retrieves the allowEmptySearch property for a specific query.
+         * @param queryName - The name of the query for which to retrieve allow empty serach property.
+         * @returns The allowEmptySearch property for the specified query, or false if not found.
+         */
+        allowEmptySearch(queryName: string): boolean;
+        /**
+         * Retrieves the customization json by name
+         * @param name - The name of the customization json
+         * @returns The customization json object or undefined if not found
+         */
+        getNamedCustomizationJson(name: string): any | undefined;
+        /**
+         * Retrieves the alias for a given column name from the application's state.
+         * If the column has aliases defined, the first alias is returned. Otherwise,
+         * the original column name is returned.
+         *
+         * @param column - The name of the column for which to retrieve the alias.
+         * @returns The alias of the column if it exists, otherwise the original column name.
+         */
+        getColumnAlias(column: string): string;
+    }, "getAggregationIcon" | "getAggregationItemsCustomization" | "getAggregationCustomization" | "getAuthorizedFilters">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    methods: {
+        /**
+         * Retrieves the icon associated with a given column's aggregation.
+         *
+         * This method searches through the store's filters to find an aggregation
+         * that matches the specified column. If a matching aggregation is found,
+         * its associated icon is returned. If no matching aggregation is found in
+         * the store's filters, the method falls back to searching in the
+         * customizationJson's filters.
+         *
+         * @param column - The name of the column for which to retrieve the aggregation icon.
+         * @returns The icon associated with the specified column's aggregation, or undefined if no matching aggregation is found.
+         */
+        getAggregationIcon(column: string): string | undefined;
+        /**
+         * Retrieves the customization items for a given column from the store's filters.
+         * If no items are found in the store's filters, it falls back to the customization JSON.
+         *
+         * @param column - The name of the column for which to retrieve customization items.
+         * @returns An array of `CFilterItem` objects if found, otherwise `undefined`.
+         */
+        getAggregationItemsCustomization(column: string): CFilterItem[] | undefined;
+        /**
+         * Retrieves the customization for a specific aggregation column.
+         * @param column - The column name for which to retrieve the customization.
+         * @returns The customization object for the specified column, or undefined if not found.
+         */
+        getAggregationCustomization(column: string): CFilter | undefined;
+        /**
+         * Retrieves the sorted aggregations based on the provided query name.
+         * @param queryName - The name of the query.
+         * @returns An array of sorted aggregations.
+         */
+        getAuthorizedFilters(route: ActivatedRoute): Aggregation[];
+    };
+}>;

package/lib/stores/application.store.d.ts

@@ -0,0 +1,106 @@
+import { SafeHtml } from '@angular/platform-browser';
+export type Extract = {
+    id: string;
+    text: SafeHtml;
+    startIndex: number;
+    relevanceIndex: number;
+    textIndex: number;
+};
+export type ApplicationState = {
+    assistantReady: boolean;
+    ready: boolean;
+    extracts: Map<string, Extract[]>;
+    hasLabelsAccess: boolean;
+};
+export declare const ApplicationStore: import("@angular/core").Type<{
+    assistantReady: import("@angular/core").Signal<boolean>;
+    ready: import("@angular/core").Signal<boolean>;
+    extracts: import("@angular/core").Signal<Map<string, Extract[]>>;
+    hasLabelsAccess: import("@angular/core").Signal<boolean>;
+    extractsCount: import("@angular/core").Signal<number>;
+    updateAssistantReady: () => void;
+    updateReadyState: (value?: boolean) => void;
+    updateHasLabelsAccess: (value?: boolean) => void;
+    updateExtracts: (id: string, extracts: Extract[]) => void;
+    getExtracts: (id: string) => Extract[] | undefined;
+} & import("@ngrx/signals").StateSignal<{
+    assistantReady: boolean;
+    ready: boolean;
+    extracts: Map<string, Extract[]>;
+    hasLabelsAccess: boolean;
+}>>;
+/**
+ * Enhances the application store with additional features.
+ *
+ * This function integrates several features into the application store, including state management,
+ * computed properties, and various methods for updating and retrieving application state.
+ *
+ * Features included:
+ * - State initialization with `intialState`.
+ * - Methods for updating the application state:
+ *   - `updateAssistantReady`: Marks the assistant as ready.
+ *   - `updateReadyState`: Sets the application store's ready state to true.
+ *
+ * @returns A configured signal store feature with state, computed properties, and methods.
+ */
+export declare function withApplicationFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<ApplicationState, "updateAssistantReady" | "updateReadyState" | "updateHasLabelsAccess">;
+    signals: Omit<{}, "updateAssistantReady" | "updateReadyState" | "updateHasLabelsAccess">;
+    methods: Omit<{}, "updateAssistantReady" | "updateReadyState" | "updateHasLabelsAccess">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    methods: {
+        /**
+         * Updates the application state to indicate that the assistant is ready.
+         * This function patches the current state by setting the `assistantReady` property to `true`.
+         */
+        updateAssistantReady(): void;
+        /**
+         * Updates the ready state of the application store to true.
+         * This function patches the current state of the store by setting the `ready` property to `true`.
+         */
+        updateReadyState(value?: boolean): void;
+        /**
+         * Updates the `hasLabelsAccess` property in the application store state.
+         *
+         * @param value - A boolean value indicating whether the user has access to labels. Defaults to `true`.
+         */
+        updateHasLabelsAccess(value?: boolean): void;
+    };
+}>;
+/**
+ * Provides features related to extracts within the application store.
+ *
+ * This function integrates state management, computed properties, and methods
+ * for handling extracts in the application store.
+ *
+ * Features:
+ * - State management for extracts.
+ * - Computed property to get the count of extracts.
+ * - Methods to update and retrieve extracts.
+ *
+ * @returns A configured signal store feature with state, computed properties, and methods for extracts.
+ */
+export declare function withExtractsFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<Omit<ApplicationState, "extractsCount">, "updateExtracts" | "getExtracts">;
+    signals: Omit<Omit<{}, "extractsCount"> & {
+        extractsCount: import("@angular/core").Signal<number>;
+    }, "updateExtracts" | "getExtracts">;
+    methods: Omit<Omit<{}, "extractsCount">, "updateExtracts" | "getExtracts">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    methods: {
+        /**
+         * Updates the extracts for a given ID in the application store.
+         *
+         * @param id - The unique identifier for the extracts to be updated.
+         * @param extracts - An array of Extract objects to be associated with the given ID.
+         */
+        updateExtracts(id: string, extracts: Extract[]): void;
+        /**
+         * Retrieves extracts from the store based on the provided ID.
+         *
+         * @param id - The unique identifier for the extracts to retrieve.
+         * @returns The extracts associated with the given ID.
+         */
+        getExtracts(id: string): Extract[] | undefined;
+    };
+}>;

package/lib/stores/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./aggregations.store";
+export * from "./app.store";
+export * from "./application.store";
+export * from "./principal.store";
+export * from "./query-params.store";
+export * from "./selection.store";
+export * from "./theme.store";
+export * from "./user-settings.store";

package/lib/stores/principal.store.d.ts

@@ -0,0 +1,53 @@
+import { Principal } from "@sinequa/atomic";
+type PrincipalState = {
+    principal: Principal;
+    userOverrideActive: boolean;
+};
+export declare const PrincipalStore: import("@angular/core").Type<{
+    userOverrideActive: import("@angular/core").Signal<boolean>;
+    principal: import("@ngrx/signals/src/deep-signal").DeepSignal<Principal>;
+    allowUserOverride: import("@angular/core").Signal<boolean>;
+    isOverridingUser: import("@angular/core").Signal<boolean>;
+    initialize: () => Promise<void>;
+} & import("@ngrx/signals").StateSignal<{
+    userOverrideActive: boolean;
+    principal: Principal;
+}>>;
+/**
+ * Enhances the store with principal-related features.
+ *
+ * This function integrates state, methods, and computed properties related to the principal.
+ *
+ * @returns A feature that can be added to a signal store.
+ *
+ * @feature
+ * - State:
+ *   - `principal`: An object representing the principal.
+ *   - `userOverrideActive`: A boolean indicating if user override is active.
+ *
+ * - Methods:
+ *   - `initialize()`: Initializes the principal state by fetching the principal data from the `PrincipalService`.
+ *
+ * - Computed Properties:
+ *   - `allowUserOverride`: A computed boolean indicating if user override is allowed based on the principal's administrator status and the `userOverrideActive` state.
+ *   - `isOverridingUser`: A computed boolean indicating if the user override is currently active.
+ */
+export declare function withPrincipalFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<Omit<PrincipalState, "initialize">, "allowUserOverride" | "isOverridingUser">;
+    signals: Omit<Omit<{}, "initialize">, "allowUserOverride" | "isOverridingUser">;
+    methods: Omit<Omit<{}, "initialize"> & {
+        /**
+         * Initializes the principal store by fetching the principal data from the principal service.
+         * It patches the store with the fetched principal data and a user override active flag from the global configuration.
+         *
+         * @returns A promise that resolves when the principal data has been fetched and the store has been patched.
+         */
+        initialize(): Promise<void>;
+    }, "allowUserOverride" | "isOverridingUser">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    signals: {
+        allowUserOverride: import("@angular/core").Signal<boolean>;
+        isOverridingUser: import("@angular/core").Signal<boolean>;
+    };
+}>;
+export {};

package/lib/stores/query-params.store.d.ts

@@ -0,0 +1,187 @@
+import { LegacyFilter, Query, SpellingCorrectionMode } from '@sinequa/atomic';
+type QueryParamsState = Partial<Omit<Query, "filters">> & {
+    path?: string;
+    filters?: LegacyFilter[];
+    id?: string;
+};
+export declare const QueryParamsStore: import("@angular/core").Type<{
+    id?: import("@angular/core").Signal<string | undefined> | undefined;
+    text?: import("@angular/core").Signal<string | undefined> | undefined;
+    filters?: import("@angular/core").Signal<LegacyFilter[] | undefined> | undefined;
+    name?: import("@angular/core").Signal<string | undefined> | undefined;
+    action?: import("@angular/core").Signal<"" | "open" | "search" | "aggregate" | undefined> | undefined;
+    select?: import("@angular/core").Signal<import("@sinequa/atomic").Select[] | undefined> | undefined;
+    open?: import("@angular/core").Signal<import("@sinequa/atomic").Open[] | undefined> | undefined;
+    page?: import("@angular/core").Signal<number | undefined> | undefined;
+    pageSize?: import("@angular/core").Signal<number | undefined> | undefined;
+    tab?: import("@angular/core").Signal<string | undefined> | undefined;
+    scope?: import("@angular/core").Signal<string | undefined> | undefined;
+    sort?: import("@angular/core").Signal<string | undefined> | undefined;
+    basket?: import("@angular/core").Signal<string | undefined> | undefined;
+    isFirstPage?: import("@angular/core").Signal<boolean | undefined> | undefined;
+    strictRefine?: import("@angular/core").Signal<boolean | undefined> | undefined;
+    globalRelevance?: import("@angular/core").Signal<number | undefined> | undefined;
+    questionLanguage?: import("@angular/core").Signal<string | undefined> | undefined;
+    questionDefaultLanguage?: import("@angular/core").Signal<string | undefined> | undefined;
+    spellingCorrectionMode?: import("@angular/core").Signal<SpellingCorrectionMode | undefined> | undefined;
+    spellingCorrectionFilter?: import("@angular/core").Signal<string | undefined> | undefined;
+    documentWeight?: import("@angular/core").Signal<string | undefined> | undefined;
+    textPartWeights?: import("@angular/core").Signal<string | undefined> | undefined;
+    relevanceTransforms?: import("@angular/core").Signal<string | undefined> | undefined;
+    removeDuplicates?: import("@angular/core").Signal<boolean | undefined> | undefined;
+    queryId?: import("@angular/core").Signal<string | undefined> | undefined;
+    aggregations?: import("@angular/core").Signal<Record<string, import("@sinequa/atomic").AggregationOptions> | string[] | undefined> | undefined;
+    orderBy?: import("@angular/core").Signal<string | undefined> | undefined;
+    groupBy?: import("@angular/core").Signal<string | undefined> | undefined;
+    neuralSearch?: import("@angular/core").Signal<boolean | undefined> | undefined;
+    path?: import("@angular/core").Signal<string | undefined> | undefined;
+    setFromUrl: (url: string) => void;
+    addFilter: (filter: LegacyFilter) => void;
+    updateFilter: (filter: LegacyFilter) => void;
+    removeFilter: (field?: string) => void;
+    removeFilterByName: (name?: string) => void;
+    clearFilters: () => void;
+    patch: (params: Partial<QueryParamsState>) => void;
+    getFilter: (fieldOrName?: string) => Partial<LegacyFilter & {
+        count: number;
+    }> | null;
+    getQuery: () => Query;
+} & import("@ngrx/signals").StateSignal<{
+    id?: string | undefined;
+    text?: string | undefined;
+    filters?: LegacyFilter[] | undefined;
+    name?: string | undefined;
+    action?: ("" | "search" | "open" | "aggregate") | undefined;
+    select?: import("@sinequa/atomic").Select[] | undefined;
+    open?: import("@sinequa/atomic").Open[] | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+    tab?: string | undefined;
+    scope?: string | undefined;
+    sort?: string | undefined;
+    basket?: string | undefined;
+    isFirstPage?: boolean | undefined;
+    strictRefine?: boolean | undefined;
+    globalRelevance?: number | undefined;
+    questionLanguage?: string | undefined;
+    questionDefaultLanguage?: string | undefined;
+    spellingCorrectionMode?: SpellingCorrectionMode | undefined;
+    spellingCorrectionFilter?: string | undefined;
+    documentWeight?: string | undefined;
+    textPartWeights?: string | undefined;
+    relevanceTransforms?: string | undefined;
+    removeDuplicates?: boolean | undefined;
+    queryId?: string | undefined;
+    aggregations?: (Record<string, import("@sinequa/atomic").AggregationOptions> | string[]) | undefined;
+    orderBy?: string | undefined;
+    groupBy?: string | undefined;
+    neuralSearch?: boolean | undefined;
+    path?: string | undefined;
+}>>;
+export declare function withQueryParamsFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<Partial<Omit<Query, "filters">> & {
+        path?: string;
+        filters?: LegacyFilter[];
+        id?: string;
+    }, "setFromUrl" | "addFilter" | "updateFilter" | "removeFilter" | "removeFilterByName" | "clearFilters" | "patch" | "getFilter" | "getQuery">;
+    signals: Omit<{}, "setFromUrl" | "addFilter" | "updateFilter" | "removeFilter" | "removeFilterByName" | "clearFilters" | "patch" | "getFilter" | "getQuery">;
+    methods: Omit<{}, "setFromUrl" | "addFilter" | "updateFilter" | "removeFilter" | "removeFilterByName" | "clearFilters" | "patch" | "getFilter" | "getQuery">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    methods: {
+        /**
+         * Sets the state from the given URL by extracting query parameters and updating the store.
+         *
+         * @param url - The URL containing query parameters to set the state from.
+         *
+         * The function performs the following steps:
+         * 1. Extracts the path from the URL.
+         * 2. Parses the query parameters from the URL.
+         * 3. Decodes and parses the filters from the query parameters.
+         * 4. Converts the page parameter to a number if it exists.
+         * 5. Updates the store state with the extracted and parsed values.
+         */
+        setFromUrl(url: string): void;
+        /**
+         * Adds a filter to the store's state.
+         *
+         * @param filter - The filter to be added to the state.
+         *
+         * The function calls the `updateFilter` method to add the filter to the state.
+         */
+        addFilter(filter: LegacyFilter): void;
+        /**
+         * Updates the filter in the store's state.
+         *
+         * @param filter - The filter to be updated. If the filter is `undefined`, the state remains unchanged.
+         *
+         * The function performs the following operations:
+         * - Adds the filter to the state if it doesn't already exist and has values.
+         * - Removes the filter if the 'between' operator is selected but no values are provided.
+         * - Removes the filter if no values are selected and the operator is not 'between'.
+         * - Updates the filter values if the filter already exists.
+         *
+         * @remarks
+         * - If the filter is `undefined`, the state remains unchanged.
+         * - If the filter's operator is 'between' and both `start` and `end` are `undefined`, the filter is removed.
+         * - If the filter's operator is not 'between' and `filters`, `value`, and `values` are all `undefined`, the filter is removed.
+         * - If the filter already exists, its values are updated.
+         */
+        updateFilter(filter: LegacyFilter): void;
+        /**
+         * Removes a filter from the store based on the specified field.
+         *
+         * @param field - The field of the filter to be removed.
+         */
+        removeFilter(field?: string): void;
+        /**
+         * Removes a filter from the state by its name.
+         *
+         * @param name - The name of the filter to be removed.
+         */
+        removeFilterByName(name?: string): void;
+        /**
+         * Clears all filters from the state.
+         *
+         * This method updates the state by setting the `filters` property to an empty array.
+         * It uses the `patchState` function to apply the state change.
+         */
+        clearFilters(): void;
+        /**
+         * Updates the current state with the provided query parameters.
+         *
+         * @param params - A partial object containing the query parameters to be updated.
+         */
+        patch(params: Partial<QueryParamsState>): void;
+        /**
+         * Retrieves a filter object based on the provided field or name.
+         *
+         * @param {string} fieldOrName - The field or name to search for in the filters.
+         * @returns {Partial<LegacyFilter & {count: number}> | null} - The filter object with an additional count property, or null if not found.
+         *
+         * The method performs the following steps:
+         * 1. Checks if the `fieldOrName` parameter is provided. If not, returns null.
+         * 2. Searches for a filter with a matching field in the store's filters.
+         * 3. If no filter is found by field, searches for a filter with a matching name.
+         * 4. If a filter is found and has a `value` property, returns the filter with a count of 1.
+         * 5. If a filter is found and does not have an array of filters, returns the filter with a count of 1.
+         * 6. If a filter is found and has a `values` property, returns the filter with the count set to the length of the `values` array.
+         * 7. If a filter is found and has an array of filters, returns the filter with the count set to the length of the `filters` array.
+         * 8. If none of the above conditions are met, returns the filter with a count of 0.
+         */
+        getFilter(fieldOrName?: string): Partial<LegacyFilter & {
+            count: number;
+        }> | null;
+        /**
+         * Constructs and returns a query object based on the current state of the store.
+         *
+         * This method retrieves various parameters from the store's state, such as filters, sort order, tab, query text, query name, and spelling correction mode.
+         * It processes the filters to separate out "concepts" filters and incorporates them into the query text.
+         * The remaining filters are combined appropriately.
+         * Finally, it builds and returns the query object using the processed parameters.
+         *
+         * @returns Query The constructed query object.
+         */
+        getQuery(): Query;
+    };
+}>;
+export {};