@sinequa/atomic-angular 0.0.140

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

@@ -0,0 +1,62 @@
+import { Article, CustomHighlights } from "@sinequa/atomic";
+export type PreviewHighlights = {
+    highlights: CustomHighlights[];
+    snippetId?: number;
+};
+type SelectionState = {
+    article: Article;
+    id: string;
+    queryText: string;
+    previewHighlights: PreviewHighlights;
+};
+/**
+ * @constant
+ * @name SelectionStore
+ * @description
+ * A store that manages the selection state of articles. It is provided in the root of the application and includes
+ * development tools for easier debugging. The store maintains the state with the following properties:
+ * - `article`: The selected article.
+ * - `id`: The ID of the selected article.
+ * - `queryText`: The query text associated with the selection.
+ *
+ * @methods
+ * - `update(article: Article, queryText?: string)`: Updates the store with a new article and optional query text.
+ * - `updateQueryText(queryText: string)`: Updates the query text in the store.
+ * - `clear()`: Clears the selection state, setting `article`, `id`, and `queryText` to `undefined`.
+ */
+export declare const SelectionStore: import("@angular/core").Type<{
+    article: import("@ngrx/signals/src/deep-signal").DeepSignal<Article>;
+    id: import("@angular/core").Signal<string>;
+    queryText: import("@angular/core").Signal<string>;
+    previewHighlights: import("@ngrx/signals/src/deep-signal").DeepSignal<PreviewHighlights>;
+    update: (newState: Partial<SelectionState>) => void;
+    clear: () => void;
+} & import("@ngrx/signals").StateSignal<{
+    article: Article;
+    id: string;
+    queryText: string;
+    previewHighlights: PreviewHighlights;
+}>>;
+export declare function withSelectionFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<SelectionState, "update" | "clear">;
+    signals: Omit<{}, "update" | "clear">;
+    methods: Omit<{}, "update" | "clear">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    methods: {
+        /**
+         * Updates the state with the provided article and optional query text.
+         *
+         * @param article - The article object to update the state with.
+         * @param queryText - Optional query text to update the state with.
+         */
+        update(newState: Partial<SelectionState>): void;
+        /**
+         * Clears the current selection state by setting the `article`, `id`, and `queryText` properties to `undefined`.
+         *
+         * @remarks
+         * This method uses the `patchState` function to update the state of the store.
+         */
+        clear(): void;
+    };
+}>;
+export {};

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

@@ -0,0 +1,55 @@
+export type CssVars = {
+    light?: Record<string, string>;
+    dark?: Record<string, string>;
+};
+export type ThemeScope = {
+    [key: string]: {
+        cssVars: CssVars;
+        darkMode?: boolean;
+        themeName: string;
+    };
+};
+export type ThemeStoreState = {
+    scopes: ThemeScope;
+};
+export declare const ThemeStore: import("@angular/core").Type<{
+    scopes: import("@angular/core").Signal<ThemeScope>;
+    loadDefaultTheme: (scope: string, darkMode?: boolean) => void;
+    setCurrentTheme: (scope: string, themeName: string, darkMode?: boolean) => void;
+    setDarkMode: (scope: string, darkMode: boolean) => void;
+} & import("@ngrx/signals").StateSignal<{
+    scopes: ThemeScope;
+}>>;
+/**
+ * Processes the CSS variables for a given theme name.
+ *
+ * @param themeName - The name of the theme to process.
+ * @returns An object containing the CSS variables for both light and dark themes.
+ * @throws Will throw an error if the theme with the specified name is not found.
+ */
+export declare function processCssVars(themeName: string): CssVars;
+/**
+ * Converts an object of theme colors to CSS variables.
+ *
+ * @param colors - An object where keys are theme color names and values are the corresponding color values.
+ * @returns An object where keys are CSS variable names and values are the corresponding color values.
+ */
+export declare function themeColorsToCssVariables(colors: any): any;
+/**
+ * Converts a camelCase theme color name to a CSS variable format.
+ *
+ * This function takes a camelCase string and transforms it into a CSS variable
+ * name by inserting hyphens between lowercase and uppercase letters and converting
+ * the entire string to lowercase.
+ *
+ * @param name - The camelCase theme color name to be converted.
+ * @returns The corresponding CSS variable name in kebab-case.
+ */
+export declare function themeColorNameToCssVariable(name: string): string;
+/**
+ * Applies a set of CSS variables to a given HTML element.
+ *
+ * @param element - The HTML element to which the CSS variables will be applied.
+ * @param cssVars - An optional record of CSS variable names and their corresponding values.
+ */
+export declare function applyThemeToNativeElement(element: HTMLElement, cssVars?: Record<string, string>): void;

package/lib/stores/user-settings.store.d.ts

@@ -0,0 +1,161 @@
+import { Article, AuditEvents, QueryParams } from '@sinequa/atomic';
+import { RecentSearch, UserSettings } from '../models/user-settings';
+export declare const UserSettingsStore: import("@angular/core").Type<{
+    bookmarks: import("@angular/core").Signal<import("../models/user-settings").Bookmark[]>;
+    recentSearches: import("@angular/core").Signal<RecentSearch[]>;
+    savedSearches: import("@angular/core").Signal<import("../models/user-settings").SavedSearch[]>;
+    assistants: import("@angular/core").Signal<Record<string, unknown>>;
+    language?: import("@angular/core").Signal<string | undefined> | undefined;
+    initialize: () => Promise<void>;
+    reset: () => Promise<void>;
+    updateBookmarks: (bookmarks: UserSettings["bookmarks"], auditEvents?: AuditEvents) => Promise<void>;
+    bookmark: (article: Article, queryName?: string) => Promise<void>;
+    unbookmark: (id: string) => Promise<void>;
+    isBookmarked: (article: Partial<Article>) => boolean;
+    toggleBookmark: (article: Article) => Promise<void>;
+    deleteRecentSearch: (index: number) => Promise<void>;
+    updateRecentSearches: (recentSearches: UserSettings["recentSearches"], auditEvents?: AuditEvents) => Promise<void>;
+    addCurrentSearch: (queryParams: QueryParams) => Promise<void>;
+    deleteSavedSearch: (index: number) => Promise<void>;
+    updateSavedSearches: (savedSearches: UserSettings["savedSearches"]) => Promise<void>;
+    updateAssistantSettings: (assistantSettings: UserSettings["assistants"]) => Promise<void>;
+    updateLanguage: (language: UserSettings["language"], auditEvents?: AuditEvents) => Promise<void>;
+} & import("@ngrx/signals").StateSignal<{
+    bookmarks: import("../models/user-settings").Bookmark[];
+    recentSearches: RecentSearch[];
+    savedSearches: import("../models/user-settings").SavedSearch[];
+    assistants: Record<string, unknown>;
+    language?: string | undefined;
+}>>;
+export declare function withUserSettingsFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<UserSettings, "initialize" | "reset">;
+    signals: Omit<{}, "initialize" | "reset">;
+    methods: Omit<{}, "initialize" | "reset">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    methods: {
+        /**
+         * Initializes the user settings store by fetching the user settings from the backend API
+         * and patching the store with the retrieved settings.
+         *
+         * @returns {Promise<void>} A promise that resolves when the initialization is complete.
+         */
+        initialize(): Promise<void>;
+        /**
+         * Resets the user settings to the initial state.
+         *
+         * This method performs the following actions:
+         * 1. Deletes the current user settings.
+         * 2. Patches the state with the initial state.
+         *
+         * @returns {Promise<void>} A promise that resolves when the reset operation is complete.
+         */
+        reset(): Promise<void>;
+    };
+}>;
+export declare function withBookmarkFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<UserSettings, "updateBookmarks" | "bookmark" | "unbookmark" | "isBookmarked" | "toggleBookmark">;
+    signals: Omit<{}, "updateBookmarks" | "bookmark" | "unbookmark" | "isBookmarked" | "toggleBookmark">;
+    methods: Omit<{}, "updateBookmarks" | "bookmark" | "unbookmark" | "isBookmarked" | "toggleBookmark">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    methods: {
+        /**
+         * Updates the user's bookmarks in the store and optionally logs audit events.
+         *
+         * @param bookmarks - An array of bookmarks to update in the user settings.
+         * @param auditEvents - Optional audit events to log during the update.
+         * @returns A promise that resolves when the update is complete.
+         */
+        updateBookmarks(bookmarks: UserSettings["bookmarks"], auditEvents?: AuditEvents): Promise<void>;
+        /**
+         * Adds an article to the bookmarks if it is not already bookmarked.
+         *
+         * @param article - The article to be bookmarked.
+         * @param queryName - Optional name of the query associated with the bookmark.
+         * @returns A promise that resolves when the bookmark has been added.
+         */
+        bookmark(article: Article, queryName?: string): Promise<void>;
+        /**
+         * Removes a bookmark by its ID.
+         *
+         * @param id - The ID of the bookmark to remove.
+         * @returns A promise that resolves when the bookmark has been removed and the bookmarks have been updated.
+         *
+         * @remarks
+         * - If the provided ID is falsy, the function will return immediately.
+         * - If the bookmark with the given ID is not found, the function will return immediately.
+         * - The function updates the bookmarks and logs the removal action with a type of "Basket_RemoveDoc".
+         */
+        unbookmark(id: string): Promise<void>;
+        /**
+         * Checks if the given article is bookmarked.
+         *
+         * @param article - An optional partial article object to check.
+         * @returns `true` if the article is bookmarked, `false` otherwise.
+         */
+        isBookmarked(article: Partial<Article>): boolean;
+        /**
+         * Toggles the bookmark status of a given article.
+         *
+         * This method checks if the article is currently bookmarked. If it is,
+         * it removes the bookmark. If it is not, it adds a bookmark.
+         *
+         * @param article - The article to toggle the bookmark status for.
+         * @returns A promise that resolves when the bookmark status has been toggled.
+         */
+        toggleBookmark(article: Article): Promise<void>;
+    };
+}>;
+export declare function withRecentSearchFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<UserSettings, "deleteRecentSearch" | "updateRecentSearches" | "addCurrentSearch">;
+    signals: Omit<{}, "deleteRecentSearch" | "updateRecentSearches" | "addCurrentSearch">;
+    methods: Omit<{}, "deleteRecentSearch" | "updateRecentSearches" | "addCurrentSearch">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    methods: {
+        /**
+         * Deletes a recent search entry from the user's recent searches list.
+         *
+         * @param {number} index - The index of the recent search to delete.
+         * @returns {Promise<void>} A promise that resolves when the recent search has been deleted and the state has been updated.
+         */
+        deleteRecentSearch(index: number): Promise<void>;
+        /**
+         * Updates the recent searches in the user settings.
+         *
+         * @param recentSearches - An array of recent searches to be updated in the user settings.
+         * @param auditEvents - Optional audit events to be logged during the update.
+         * @returns A promise that resolves when the recent searches have been updated.
+         */
+        updateRecentSearches(recentSearches: UserSettings["recentSearches"], auditEvents?: AuditEvents): Promise<void>;
+        /**
+         * Adds the current search to the recent searches list.
+         *
+         * This method checks if a search with the same label already exists in the recent searches.
+         * If it does, it updates the existing search with the new query parameters and date.
+         * If it does not, it adds a new search to the recent searches list.
+         *
+         * @param queryParams - The parameters of the current search.
+         * @returns A promise that resolves when the recent searches have been updated.
+         */
+        addCurrentSearch(queryParams: QueryParams): Promise<void>;
+    };
+}>;
+export declare function withSavedSearchFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<UserSettings, "deleteSavedSearch" | "updateSavedSearches">;
+    signals: Omit<{}, "deleteSavedSearch" | "updateSavedSearches">;
+    methods: Omit<{}, "deleteSavedSearch" | "updateSavedSearches">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    methods: {
+        deleteSavedSearch(index: number): Promise<void>;
+        updateSavedSearches(savedSearches: UserSettings["savedSearches"]): Promise<void>;
+    };
+}>;
+export declare function withAssistantFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult, {
+    state: Omit<UserSettings, "updateAssistantSettings" | "updateLanguage">;
+    signals: Omit<{}, "updateAssistantSettings" | "updateLanguage">;
+    methods: Omit<{}, "updateAssistantSettings" | "updateLanguage">;
+} & import("@ngrx/signals/src/signal-store-models").EmptyFeatureResult & {
+    methods: {
+        updateAssistantSettings(assistantSettings: UserSettings["assistants"]): Promise<void>;
+        updateLanguage(language: UserSettings["language"], auditEvents?: AuditEvents): Promise<void>;
+    };
+}>;

package/lib/tokens/highlights.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from "@angular/core";
+export type PreviewHighlightName = 'company' | 'geo' | 'person' | 'extractslocations' | 'matchlocations';
+export type PreviewHighlight = {
+    name: PreviewHighlightName;
+    color: string;
+    bgColor: string;
+};
+export declare const HIGHLIGHTS: InjectionToken<PreviewHighlight[]>;

package/lib/tokens/index.d.ts

@@ -0,0 +1 @@
+export * from "./highlights";

package/lib/utils/debounced-signal.d.ts

@@ -0,0 +1,25 @@
+import { Signal } from "@angular/core";
+/**
+ * Creates a debounced signal that updates its value after a specified timeout.
+ *
+ * @template T - The type of the signal value.
+ * @param Signal<T> input - The input signal whose value will be debounced.
+ * @param number [timeOutMs=0] - The debounce timeout in milliseconds. Defaults to 0.
+ * @returns Signal<T> - A new signal that updates its value after the specified debounce timeout.
+ *
+ * @example
+ * ```ts
+ * const input = signal('');
+ * const debounced = debouncedSignal(input, 1000);
+ *
+ * contructor() {
+ *  effect(() => {
+ *   console.log(debounced());
+ *   // will log the input value after 1 second of inactivity.
+ *  });
+ * }
+ * ...
+ * <input [ngModel]="input()" (ngModelChange)="input.set($event)">
+ * ```
+ */
+export declare function debouncedSignal<T>(input: Signal<T>, timeOutMs?: number): Signal<T>;

package/lib/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './inline-worker';
+export * from './query';
+export * from './routes';
+export * from './tailwind-utils';
+export * from './theme-body-hook';
+export * from './theme-registry';
+export * from './debounced-signal';

package/lib/utils/inline-worker.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+export declare class InlineWorker {
+    private readonly worker;
+    private onMessage;
+    private onError;
+    constructor(func: () => void);
+    postMessage(data: unknown): void;
+    onmessage(): Observable<MessageEvent>;
+    onerror(): Observable<ErrorEvent>;
+    terminate(): void;
+}

package/lib/utils/query.d.ts

@@ -0,0 +1,26 @@
+import { Query } from '@sinequa/atomic';
+/**
+ * Retrieves the query name from the current route.
+ *
+ * @remarks
+ * This function must be used within an injection context.
+ *
+ * This function traverses the route tree recursively to find the query name.
+ * It first checks for a query parameter `t` in the route's snapshot. If the query name is not found
+ * in the route data, it attempts to find it in the child routes of the "search" route.
+ * If the query name is still not found, it falls back to the `queryName` defined in the route's data.
+ *
+ * @returns {string | undefined} The query name if found, otherwise `undefined`.
+ */
+export declare function getQueryNameFromRoute(): string | undefined;
+/**
+ * Builds a query object based on the provided partial query.
+ * If any properties are missing in the partial query, default values are used.
+ *
+ * @remarks
+ * This function must be used within an injection context.
+ *
+ * @param query - The partial query object.
+ * @returns The complete query object.
+ */
+export declare function buildQuery(query?: Partial<Query>): Query;

package/lib/utils/routes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Retrieves the current path from the Angular `ActivatedRoute` service.
+ *
+ * @returns {string | undefined} The current path as a string, or `undefined` if the path cannot be determined.
+ */
+export declare function getCurrentPath(): string | undefined;
+/**
+ * Retrieves the current query name based on the current path and router configuration.
+ *
+ * This function asserts that it is being called within an injection context and then
+ * uses Angular's dependency injection to get the router configuration. It matches the
+ * current path against the router's configuration to find the corresponding query name.
+ *
+ * @returns {string | undefined} The name of the current query if found, otherwise undefined.
+ */
+export declare function getCurrentQueryName(): string | undefined;

package/lib/utils/tailwind-utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/lib/utils/theme-body-hook.d.ts

@@ -0,0 +1,6 @@
+import { ApplicationRef } from "@angular/core";
+export type ThemeBodyHookParameters = {
+    scope: string;
+    theme: string;
+};
+export declare function withThemeBodyHook(app: ApplicationRef, params: ThemeBodyHookParameters | undefined): ApplicationRef;

package/lib/utils/theme-registry.d.ts

@@ -0,0 +1,3 @@
+import { ApplicationRef } from "@angular/core";
+import { Theme } from "../resources";
+export declare function withThemes(app: ApplicationRef, themes: Theme[]): ApplicationRef;

package/lib/web-services/aggregations.service.d.ts

@@ -0,0 +1,60 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Aggregation, AuditEvents, Query, TreeAggregation, TreeAggregationNode } from '@sinequa/atomic';
+import { QueryService } from './query.service';
+import * as i0 from "@angular/core";
+export declare class AggregationsService {
+    protected readonly http: HttpClient;
+    protected readonly queryService: QueryService;
+    appStore: {
+        webServices: import("@angular/core").Signal<Record<string, import("@sinequa/atomic").CCWebService>>;
+        data: import("@ngrx/signals/src/deep-signal").DeepSignal<import("@sinequa/atomic-angular").CJson>;
+        queries: import("@angular/core").Signal<Record<string, import("@sinequa/atomic").CCQuery>>;
+        customJSONs: import("@angular/core").Signal<import("@sinequa/atomic-angular").CJ[]>;
+        filters: import("@angular/core").Signal<import("@sinequa/atomic-angular").CFilter[]>;
+        sources: import("@angular/core").Signal<import("@sinequa/atomic-angular").CSources | {
+            routes?: [];
+            filters?: import("@sinequa/atomic-angular").CFilter[];
+        }>;
+        customizationJson: import("@angular/core").Signal<import("@sinequa/atomic-angular").CJson>;
+        update: (app: import("@sinequa/atomic").CCApp) => void;
+        initialize: () => Promise<void>;
+        initializeWithAppName: (appName: string) => Promise<void>;
+        getWebServiceByType: (type: import("@sinequa/atomic").CCWebService["webServiceType"]) => import("@sinequa/atomic").CCWebService | undefined;
+        getLabels: () => {
+            private: string;
+            public: string;
+        };
+        getQueryByName: (name: string) => import("@sinequa/atomic").CCQuery | undefined;
+        getQueryByIndex: (index: number) => import("@sinequa/atomic").CCQuery | undefined;
+        getDefaultQuery: () => import("@sinequa/atomic").CCQuery | undefined;
+        allowEmptySearch: (queryName: string) => boolean;
+        getNamedCustomizationJson: (name: string) => any | undefined;
+        getColumnAlias: (column: string) => string;
+        getAggregationIcon: (column: string) => string | undefined;
+        getAggregationItemsCustomization: (column: string) => import("@sinequa/atomic-angular").CFilterItem[] | undefined;
+        getAggregationCustomization: (column: string) => import("@sinequa/atomic-angular").CFilter | undefined;
+        getAuthorizedFilters: (route: import("@angular/router").ActivatedRoute) => Aggregation[];
+    } & import("@ngrx/signals").StateSignal<{
+        webServices: Record<string, import("@sinequa/atomic").CCWebService>;
+        data: import("@sinequa/atomic-angular").CJson;
+        queries: Record<string, import("@sinequa/atomic").CCQuery>;
+        customJSONs: import("@sinequa/atomic-angular").CJ[];
+    }>;
+    aggregationsStore: {
+        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[];
+    }>;
+    protected API_URL: string;
+    loadMore(query: Partial<Query>, aggregation: Aggregation, audit?: AuditEvents): Observable<Aggregation>;
+    open(query: Partial<Query>, aggregation: TreeAggregation, item: TreeAggregationNode): Observable<TreeAggregation>;
+    private findNode;
+    private replaceInTree;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AggregationsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AggregationsService>;
+}

package/lib/web-services/app.service.d.ts

@@ -0,0 +1,30 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { CCApp } from '@sinequa/atomic';
+import * as i0 from "@angular/core";
+export declare class AppService {
+    protected readonly http: HttpClient;
+    protected readonly API_URL: string;
+    /**
+     * Retrieves the application configuration from the server.
+     *
+     * @param appName - The name of the application to fetch the configuration for.
+     *
+     * @returns {Observable<CCApp>} An observable that emits the application configuration.
+     *
+     * @remarks
+     * This method constructs an HTTP GET request to fetch the application configuration
+     * using the `app` parameter from the global configuration. If the request fails,
+     * it logs the error to the console and returns an empty observable.
+     *
+     * @example
+     * ```typescript
+     * appService.getApp().subscribe(appConfig => {
+     *   console.log(appConfig);
+     * });
+     * ```
+     */
+    getApp(appName?: string): Observable<CCApp>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
+}

package/lib/web-services/audit.service.d.ts

@@ -0,0 +1,75 @@
+import { HttpClient } from "@angular/common/http";
+import { Router } from "@angular/router";
+import { Article, AuditEvents, AuditEventType, AuditEventTypeValues, CCApp, Result } from "@sinequa/atomic";
+import * as i0 from "@angular/core";
+export declare class AuditService {
+    appStore: {
+        webServices: import("@angular/core").Signal<Record<string, import("@sinequa/atomic").CCWebService>>;
+        data: import("@ngrx/signals/src/deep-signal").DeepSignal<import("@sinequa/atomic-angular").CJson>;
+        queries: import("@angular/core").Signal<Record<string, import("@sinequa/atomic").CCQuery>>;
+        customJSONs: import("@angular/core").Signal<import("@sinequa/atomic-angular").CJ[]>;
+        filters: import("@angular/core").Signal<import("@sinequa/atomic-angular").CFilter[]>;
+        sources: import("@angular/core").Signal<import("@sinequa/atomic-angular").CSources | {
+            routes?: [];
+            filters?: import("@sinequa/atomic-angular").CFilter[];
+        }>;
+        customizationJson: import("@angular/core").Signal<import("@sinequa/atomic-angular").CJson>;
+        update: (app: CCApp) => void;
+        initialize: () => Promise<void>;
+        initializeWithAppName: (appName: string) => Promise<void>;
+        getWebServiceByType: (type: import("@sinequa/atomic").CCWebService["webServiceType"]) => import("@sinequa/atomic").CCWebService | undefined;
+        getLabels: () => {
+            private: string;
+            public: string;
+        };
+        getQueryByName: (name: string) => import("@sinequa/atomic").CCQuery | undefined;
+        getQueryByIndex: (index: number) => import("@sinequa/atomic").CCQuery | undefined;
+        getDefaultQuery: () => import("@sinequa/atomic").CCQuery | undefined;
+        allowEmptySearch: (queryName: string) => boolean;
+        getNamedCustomizationJson: (name: string) => any | undefined;
+        getColumnAlias: (column: string) => string;
+        getAggregationIcon: (column: string) => string | undefined;
+        getAggregationItemsCustomization: (column: string) => import("@sinequa/atomic-angular").CFilterItem[] | undefined;
+        getAggregationCustomization: (column: string) => import("@sinequa/atomic-angular").CFilter | undefined;
+        getAuthorizedFilters: (route: import("@angular/router").ActivatedRoute) => import("@sinequa/atomic").Aggregation[];
+    } & import("@ngrx/signals").StateSignal<{
+        webServices: Record<string, import("@sinequa/atomic").CCWebService>;
+        data: import("@sinequa/atomic-angular").CJson;
+        queries: Record<string, import("@sinequa/atomic").CCQuery>;
+        customJSONs: import("@sinequa/atomic-angular").CJ[];
+    }>;
+    app: import("@angular/core").Signal<CCApp>;
+    protected readonly http: HttpClient;
+    protected readonly router: Router;
+    protected readonly API_URL: string;
+    protected lastClickTime: number;
+    /**
+     * Notify the Sinequa server of a set of audit events
+     *
+     * @param auditEvents The audit events
+     */
+    notify(auditEvents: AuditEvents): void;
+    /**
+     * It sends an audit event to the Audit Service.
+     */
+    notifyLogin(): void;
+    /**
+     * Notify logout
+     */
+    notifyLogout(): void;
+    /**
+       * Notify the Sinequa server of a document event
+       *
+       * @param evt The audit event type
+       * @param doc The document (article) in question
+       * @param resultId The resultid that contain the document
+       * @param parameters Additional parameters
+       */
+    notifyDocument(auditEventType: AuditEventType | AuditEventTypeValues | {} & Record<never, never>, doc: Article, resultsOrId: Result | string, parameters?: Record<string, string | number | boolean | undefined>, rfmParameters?: Record<string, string | number | boolean | undefined>): void;
+    /**
+     * Notify route change
+     */
+    notifyRouteChange(url: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuditService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuditService>;
+}

package/lib/web-services/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./aggregations.service";
+export * from "./app.service";
+export * from "./json-method-plugin.service";
+export * from "./preview.service";
+export * from "./principal.service";
+export * from "./query.service";
+export * from "./text-chunck.service";
+export * from "./audit.service";
+export * from "./audit.service";

package/lib/web-services/json-method-plugin.service.d.ts

@@ -0,0 +1,41 @@
+import { HttpClient, HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+type Options = {
+    headers?: HttpHeaders | {
+        [header: string]: string | string[];
+    };
+    context?: HttpContext;
+    observe?: 'body' | 'events' | 'response';
+    params?: HttpParams | {
+        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+    };
+    reportProgress?: boolean;
+    responseType: 'arraybuffer' | 'blob' | 'text' | 'json';
+    withCredentials?: boolean;
+};
+export declare class JsonMethodPluginService {
+    protected readonly http: HttpClient;
+    protected readonly API_URL: string;
+    /**
+     * Call a JsonMethod plugin using an HTTP POST
+     *
+     * @param method The name of the JsonMethod plugin
+     * @param query Parameters to pass to the plugin
+     * @param options HTTP options for the request
+     * @returns An observable of the plugin's return value
+     */
+    post<U>(method: string, query: U, options?: Options): Observable<any>;
+    /**
+     * Call a JsonMethod plugin using an HTTP GET
+     *
+     * @param method The name of the JsonMethod plugin
+     * @param query Parameters to pass to the plugin
+     * @param options HTTP options for the request
+     * @returns An observable of the plugin's return value
+     */
+    get<U extends Record<string, string | boolean | number | Date | object | undefined>>(method: string, query: U, options?: Options): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonMethodPluginService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JsonMethodPluginService>;
+}
+export {};