@sinequa/assistant 3.10.5 → 3.10.10

package/chat/index.d.ts

@@ -1,5 +1,2157 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter, OnChanges, ChangeDetectorRef, ElementRef, TemplateRef, SimpleChanges, InjectionToken, Type, AfterViewInit, Injector } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Observable, Subscription } from 'rxjs';
+import { TranslocoService } from '@jsverse/transloco';
+import { MessageHeaders, HttpTransportType, ITransport, HubConnection } from '@microsoft/signalr';
+import { CCApp, Principal, Article, Query, AppGlobalConfig } from '@sinequa/atomic';
+import { z } from 'zod';
+import { FlowDirective, Transfer } from '@flowjs/ngx-flow';
+import { HttpClient } from '@angular/common/http';
+import MarkdownIt from 'markdown-it';
+
+declare class AppService {
+    app: CCApp | undefined;
+    init(): Promise<void>;
+    get appName(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
+}
+
+type NotificationType = "success" | "warning" | "error";
+declare class NotificationsService {
+    success(message: string, title?: string): void;
+    warning(message: string, title?: string): void;
+    error(message: string, title?: string): void;
+    private dispatchEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationsService>;
+}
+
+declare class PrincipalService {
+    principal: Principal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrincipalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PrincipalService>;
+}
+
+declare class UserSettingsWebService {
+    userSettings: {};
+    patch(data: any): rxjs.Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserSettingsWebService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserSettingsWebService>;
+}
+
+/** Supported message type */
+type MessageType = "text" | "image" | "video";
+/** Generic message content schema */
+type MessageContent = {
+    type: MessageType;
+};
+type RawMessageContent = string | MessageContent[];
+
+/** Type of a context image reference */
+type MessageImageReference = {
+    name?: string;
+    description?: string;
+    url?: string;
+    type?: string;
+    mimeType?: string;
+    article?: Article;
+    articleId?: string;
+    $partId?: number;
+    parts?: DocumentPart[];
+};
+
 /**
- * Generated bundle index. Do not edit.
+ * Individual message sent & returned by the ChatGPT API.
+ * If this message is an attachment, we attach the minimal
+ * information needed to reconstruct this attachment (RawAttachment)
+ * as well as the reference id computed at the moment of sending
+ * the attachment to the API.
  */
-/// <amd-module name="@sinequa/assistant/chat" />
-export * from './public-api';
+interface RawMessage {
+    role: string;
+    content: RawMessageContent;
+    messageType?: "CHART" | "MARKDOWN";
+    additionalProperties: {
+        [key: string]: any;
+    };
+}
+/**
+ * A chat message that has been processed to include the markdown-formatted
+ * content for display, as well as detailed attachment data, and optionally
+ * a list of the references extracted from that message
+ */
+interface ChatMessage extends RawMessage {
+    additionalProperties: {
+        messageId: string;
+        display?: boolean;
+        $progress?: ChatProgress[];
+        $attachment?: ChatContextAttachment[];
+        $suggestedAction?: SuggestedAction[];
+        $debug?: DebugMessage[];
+        forcedWorkflow?: string;
+        forcedWorkflowProperties?: any;
+        query?: Query;
+        isUserInput?: boolean;
+        usageMetrics?: ChatUsageMetrics;
+        additionalWorkflowProperties?: any;
+        $liked?: boolean;
+        $disliked?: boolean;
+        [key: string]: any;
+    };
+}
+interface ChatProgress {
+    title: string;
+    content?: string;
+    done?: boolean;
+    time?: number;
+}
+interface RawAttachment {
+    /** Type of the attachment */
+    type: string;
+    /** Record id from which this attachment is taken */
+    recordId: string;
+    /** Record from which this this attachment is taken */
+    record: Article;
+}
+interface DocumentPart {
+    partId?: number;
+    offset: number;
+    length: number;
+    text?: string;
+    images?: string[] | MessageImageReference[];
+}
+type DocumentPage = {
+    url: string;
+    mimeType: string;
+    name?: string;
+    type?: string;
+    description?: string;
+    length?: number;
+    offSet?: number;
+    pageNumber?: number;
+    remappedLength?: number;
+    remappedOffset?: number;
+};
+interface ChatContextAttachment extends RawAttachment {
+    /** Type of the attachment */
+    type: "Context";
+    /** Rank of the attachment in the context message */
+    contextId: number;
+    /** Parts of the record that the assistant uses to answer */
+    parts: DocumentPart[];
+    /** Pages of the documents based on the query */
+    pages?: DocumentPage[];
+    /** The specific id used of the referenced part */
+    $partId?: number;
+    $expanded?: boolean;
+}
+/**
+ * Raw response of the chat API
+ */
+interface RawResponse {
+    history: RawMessage[];
+    executionTime: string | undefined;
+    executionTimeMilliseconds: number | undefined;
+}
+/**
+ * Enriched response of the chat API
+ */
+interface ChatResponse extends RawResponse {
+    history: ChatMessage[];
+}
+/**
+ * Response of the ListModels API
+ */
+interface GllmModelDescription {
+    provider: string;
+    displayName: string;
+    serviceId: string;
+    modelId: string;
+    enable: boolean;
+    maxGenerationSize: number;
+    contextWindowSize: number;
+}
+/**
+ * Response of the ListFunctions API
+ */
+interface GllmFunction {
+    functionName: string;
+    description: string;
+    enabled: boolean;
+    parameters: GllmFunctionParameter[];
+}
+interface GllmFunctionParameter {
+    description: string;
+    isRequired: boolean;
+    name: string;
+    type: string;
+}
+/**
+ * Minimal representation of a saved chat
+ */
+interface SavedChat {
+    id: string;
+    title: string;
+    modifiedUTC: string;
+}
+/**
+ * Data structure saved to reconstruct a saved chat conversation
+ */
+interface SavedChatHistory extends SavedChat {
+    history: ChatMessage[];
+}
+declare const connectionSettingsSchema: z.ZodObject<{
+    connectionErrorMessage: z.ZodString;
+    websocketEndpoint: z.ZodOptional<z.ZodString>;
+    signalRSkipNegotiation: z.ZodOptional<z.ZodBoolean>;
+    signalRTransport: z.ZodEnum<{
+        None: "None";
+        WebSockets: "WebSockets";
+        ServerSentEvents: "ServerSentEvents";
+        LongPolling: "LongPolling";
+    }>;
+    signalRLogLevel: z.ZodEnum<{
+        None: "None";
+        Critical: "Critical";
+        Debug: "Debug";
+        Error: "Error";
+        Information: "Information";
+        Trace: "Trace";
+        Warning: "Warning";
+    }>;
+    signalRServerTimeoutInMilliseconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type ConnectionSettings = z.infer<typeof connectionSettingsSchema>;
+declare const serviceSettingsSchema: z.ZodObject<{
+    service_id: z.ZodString;
+    model_id: z.ZodString;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+interface ServiceSettings extends z.infer<typeof serviceSettingsSchema> {
+}
+declare const additionalServiceSettingsSchema: z.ZodObject<{}, z.core.$strip>;
+interface AdditionalServiceSettings extends z.infer<typeof additionalServiceSettingsSchema> {
+}
+declare const additionalWorkflowPropertiesSchema: z.ZodObject<{}, z.core.$strip>;
+interface additionalWorkflowProperties extends z.infer<typeof additionalWorkflowPropertiesSchema> {
+}
+declare const uiSettingsSchema: z.ZodObject<{
+    display: z.ZodBoolean;
+    servicesModels: z.ZodBoolean;
+    functions: z.ZodBoolean;
+    temperature: z.ZodBoolean;
+    top_p: z.ZodBoolean;
+    max_tokens: z.ZodBoolean;
+    debug: z.ZodBoolean;
+    displaySystemPrompt: z.ZodBoolean;
+    displayUserPrompt: z.ZodBoolean;
+}, z.core.$strip>;
+interface UiSettings extends z.infer<typeof uiSettingsSchema> {
+}
+declare const defaultValuesSchema: z.ZodObject<{
+    service_id: z.ZodString;
+    model_id: z.ZodString;
+    functions: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        enabled: z.ZodBoolean;
+    }, z.core.$strip>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+    debug: z.ZodBoolean;
+    systemPrompt: z.ZodString;
+    userPrompt: z.ZodString;
+}, z.core.$strip>;
+interface DefaultValues extends z.infer<typeof defaultValuesSchema> {
+}
+declare const modeSettingsSchema: z.ZodObject<{
+    enabledUserInput: z.ZodBoolean;
+    displayUserPrompt: z.ZodBoolean;
+    sendUserPrompt: z.ZodBoolean;
+    initialization: z.ZodObject<{
+        event: z.ZodEnum<{
+            Query: "Query";
+            Prompt: "Prompt";
+        }>;
+        forcedWorkflow: z.ZodOptional<z.ZodString>;
+        forcedFunction: z.ZodOptional<z.ZodString>;
+        displayUserQuery: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        forcedWorkflow: z.ZodString;
+        forcedWorkflowProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+interface ModeSettings extends z.infer<typeof modeSettingsSchema> {
+}
+declare const savedChatSettingsSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    display: z.ZodBoolean;
+    queryWebserviceForSearch: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface SavedChatSettings extends z.infer<typeof savedChatSettingsSchema> {
+}
+interface SavedChatSettings extends z.infer<typeof savedChatSettingsSchema> {
+}
+declare const chatConfigSchema: z.ZodObject<{
+    connectionSettings: z.ZodObject<{
+        connectionErrorMessage: z.ZodString;
+        websocketEndpoint: z.ZodOptional<z.ZodString>;
+        signalRSkipNegotiation: z.ZodOptional<z.ZodBoolean>;
+        signalRTransport: z.ZodEnum<{
+            None: "None";
+            WebSockets: "WebSockets";
+            ServerSentEvents: "ServerSentEvents";
+            LongPolling: "LongPolling";
+        }>;
+        signalRLogLevel: z.ZodEnum<{
+            None: "None";
+            Critical: "Critical";
+            Debug: "Debug";
+            Error: "Error";
+            Information: "Information";
+            Trace: "Trace";
+            Warning: "Warning";
+        }>;
+        signalRServerTimeoutInMilliseconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    defaultValues: z.ZodObject<{
+        service_id: z.ZodString;
+        model_id: z.ZodString;
+        functions: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        max_tokens: z.ZodOptional<z.ZodNumber>;
+        debug: z.ZodBoolean;
+        systemPrompt: z.ZodString;
+        userPrompt: z.ZodString;
+    }, z.core.$strip>;
+    modeSettings: z.ZodObject<{
+        enabledUserInput: z.ZodBoolean;
+        displayUserPrompt: z.ZodBoolean;
+        sendUserPrompt: z.ZodBoolean;
+        initialization: z.ZodObject<{
+            event: z.ZodEnum<{
+                Query: "Query";
+                Prompt: "Prompt";
+            }>;
+            forcedWorkflow: z.ZodOptional<z.ZodString>;
+            forcedFunction: z.ZodOptional<z.ZodString>;
+            displayUserQuery: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            forcedWorkflow: z.ZodString;
+            forcedWorkflowProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    uiSettings: z.ZodObject<{
+        display: z.ZodBoolean;
+        servicesModels: z.ZodBoolean;
+        functions: z.ZodBoolean;
+        temperature: z.ZodBoolean;
+        top_p: z.ZodBoolean;
+        max_tokens: z.ZodBoolean;
+        debug: z.ZodBoolean;
+        displaySystemPrompt: z.ZodBoolean;
+        displayUserPrompt: z.ZodBoolean;
+    }, z.core.$strip>;
+    savedChatSettings: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        display: z.ZodBoolean;
+        queryWebserviceForSearch: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    globalSettings: z.ZodObject<{
+        searchWarningMessage: z.ZodString;
+        disclaimer: z.ZodOptional<z.ZodString>;
+        genericChatErrorMessage: z.ZodOptional<z.ZodString>;
+        displayUserQuotaConsumption: z.ZodOptional<z.ZodBoolean>;
+        displayChatTokensConsumption: z.ZodOptional<z.ZodBoolean>;
+        collapseReferences: z.ZodOptional<z.ZodBoolean>;
+        automaticScroll: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    auditSettings: z.ZodObject<{
+        issueTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        logContent: z.ZodBoolean;
+    }, z.core.$strip>;
+    additionalServiceSettings: z.ZodObject<{}, z.core.$strip>;
+    additionalWorkflowProperties: z.ZodObject<{}, z.core.$strip>;
+}, z.core.$strip>;
+interface ChatConfig extends z.infer<typeof chatConfigSchema> {
+}
+interface ChatPayload {
+    debug: boolean;
+    functions: string[];
+    history: ChatMessage[];
+    serviceSettings: ServiceSettings;
+    appQuery: {
+        app: string;
+        query: Query | undefined;
+        targetUrl?: string;
+        accessToken?: string;
+    };
+    instanceId: string;
+    chatId: string;
+    genericChatErrorMessage?: string;
+}
+type ActionMessage = {
+    guid: string;
+    displayName?: string;
+    displayValue?: string;
+    executionTime?: number;
+};
+interface TextChunksOptions {
+    extendMode?: "None" | "Sentence" | "Chars";
+    extendScope?: number;
+}
+interface Quota {
+    lastRequest: string;
+    promptTokenCount: number;
+    completionTokenCount: number;
+    periodTokens: number;
+    resetHours: number;
+    tokenCount: number;
+    nextReset: string;
+    lastResetUTC: string;
+    nextResetUTC: string;
+    maxQuotaReached: boolean;
+}
+interface SuggestedAction {
+    content: string;
+    type: string;
+}
+interface InitChat {
+    messages: RawMessage[];
+}
+/**
+ * List of events data that can be emitted by the websocket chat endpoint
+ */
+type SuggestedActionsEvent = {
+    suggestedActions: SuggestedAction[];
+};
+type QuotaEvent = {
+    quota: Quota;
+};
+type MessageEvent = {
+    delta: string;
+    messageId: string;
+};
+type ContextMessageEvent = {
+    content: string;
+    additionalProperties: ChatContextAttachment;
+};
+type ErrorEvent = string;
+type ActionStartEvent = {
+    guid: string;
+    displayName: string;
+};
+type ActionResultEvent = {
+    guid: string;
+    displayValue: string;
+};
+type ActionStopEvent = {
+    guid: string;
+    executionTime: number;
+};
+type HistoryEvent = {
+    history: RawMessage[];
+    executionTime: string;
+    executionTimeMilliseconds?: number;
+};
+type DebugMessageEvent = DebugMessage;
+/**
+ * Data emitted by the http chat endpoint
+ */
+type HttpChatResponse = {
+    quota: Quota;
+    suggestedActions: SuggestedAction[];
+    debug: any;
+    context: {
+        content: string;
+        additionalProperties: ChatContextAttachment;
+    }[];
+    actions: ActionMessage[];
+    history: RawMessage[];
+    executionTime: string;
+    executionTimeMilliseconds: number;
+};
+interface TokenConsumption {
+    percentage: number;
+}
+interface UserTokenConsumption extends TokenConsumption {
+    nextResetDate: string;
+}
+interface ChatUsageMetrics {
+    totalTokenCount: number;
+    promptTokenCount: number;
+    completionTokenCount: number;
+    tokenizerType: string;
+}
+interface KvObject {
+    data: {
+        key: string;
+        value: any;
+    };
+    type: "KV";
+    isError: boolean;
+}
+interface ListObject {
+    name: string;
+    type: "LIST";
+    isError: boolean;
+    items: (KvObject | ListObject)[];
+    expanded: boolean;
+}
+type DebugMessage = {
+    title: string;
+    chatId: string;
+    executionId: string;
+    debugMessageId: string;
+    $expanded?: boolean;
+    $loading?: boolean;
+    $details?: ListObject[];
+};
+type MessageHandler<T> = {
+    handler: (data: T) => void;
+    isGlobalHandler: boolean;
+};
+/**
+ * Data emitted by the saved chat endpoints
+ */
+type DeleteSavedChatResponse = {
+    deleteCount: number;
+    executionTime: string;
+    executionTimeMilliseconds: number;
+};
+type SavedChatResponse = {
+    savedChat: SavedChat;
+    executionTime: string;
+    executionTimeMilliseconds: number;
+};
+/** */
+type PluginVersion = {
+    pluginVersion: string;
+    major: number;
+    minor: number;
+    build: number;
+};
+
+interface ConnectionOptions {
+    withCredentials?: boolean;
+    headers?: MessageHeaders;
+    transport?: HttpTransportType | ITransport;
+    skipNegotiation?: boolean;
+    accessTokenFactory?: () => string | Promise<string>;
+}
+
+declare class AssistantUtils {
+    readonly localID: string | null;
+    protected readonly transloco: TranslocoService;
+    /**
+     * Retrieves the rank (1-based index) of a message within a chat history array based on its message ID.
+     * If the message is not found, returns -1.
+     *
+     * @param array - An array of `ChatMessage` objects or `undefined`. Represents the chat history.
+     * @param messageId - The unique identifier of the message to locate.
+     * @returns The 1-based index of the message in the array, or -1 if the message is not found.
+     */
+    getMessageRankInChatHistory(array: ChatMessage[] | undefined, messageId: string): number;
+    /**
+     * Traverse the array from the end and track the first 'assistant' message among the last group of "assistant" messages where display is true
+     * @param array The array of ChatMessage to traverse
+     * @returns The index of the first visible assistant message among the last group of "assistant" messages in the array
+     */
+    firstVisibleAssistantMessageIndex(array: ChatMessage[] | undefined): number;
+    /**
+     * Traverse the array from the end and pick the last 'assistant' message among the last group of "assistant" messages where display is true
+     * @param array The array of ChatMessage to traverse
+     *   @returns The index of the last visible assistant message among the last group of "assistant" messages in the array
+     */
+    lastVisibleAssistantMessageIndex(array: ChatMessage[] | undefined): number;
+    /**
+     * Format a date string in UTC to a local date string
+     * @param value Date string in UTC to format
+     * @returns A formatted local date string
+     */
+    formatDateTime(value: string): string;
+    /**
+     * Takes a text prompt that may contain placeholders for variables
+     * and replaces these placeholders if it finds a match in the given
+     * context object.
+     *
+     * @example
+     * const p = "Hello, [[user.name]]! You have [[user.notifications.length]] new notifications.";
+     * const context = {
+     *     user: {
+     *         name: "Alice",
+     *         notifications: ["Message from Bob", "Reminder for meeting"]
+     *     }
+     * };
+     * const formattedPrompt = formatPrompt(p, context);
+     * console.log(formattedPrompt); // Output: "Hello, Alice! You have 2 new notifications."
+     */
+    static formatPrompt(prompt: string, context: any): string;
+    /**
+     * Determines a time-based key for a given date to be used for translations or formatting.
+     * The key represents a relative time period such as "today", "yesterday", "this week", etc.
+     * If the date does not fall into any predefined relative time period, it returns the year as a string.
+     *
+     * @param date - The date for which the time key is to be determined.
+     * @returns A string representing the time key, which can be used for translation or display purposes.
+     */
+    getTimeKey(date: Date): string;
+    /**
+     * Get the current locale name.
+     * @returns The current locale name or an empty string if not available.
+     */
+    getCurrentLocaleName(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssistantUtils, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AssistantUtils>;
+}
+
+declare class ChatService {
+    /** Name of the assistant websocket endpoint. */
+    WS_REQUEST_URL: string;
+    /** Name of the assistant REST endpoint. */
+    REST_REQUEST_URL: string;
+    /** SignalR connection instance */
+    connection: HubConnection | undefined;
+    /** Emit true once the initialization of the assistant process is done. */
+    initProcess$: BehaviorSubject<boolean>;
+    /** Emit true once the initialization of the assistant config is done. */
+    initConfig$: BehaviorSubject<boolean>;
+    /** Emit the global configuration of the assistant. */
+    assistantConfig$: BehaviorSubject<ChatConfig | undefined>;
+    /** Emit true if the user has been overridden, false otherwise. */
+    userOverride$: BehaviorSubject<boolean | undefined>;
+    /**
+     * Emit true if the fetch of an assistant's response is ongoing (it includes Streaming status of the assistant endpoint AND saving the discussion if save Chat is enabled).
+     * This is used to prevent multiple fetches at the same time.
+     * Typically, there is no problem chaining fetches, but when forcing a reload after query changes cases, it can't be allowed because it breaks the whole business logic.
+    */
+    streaming$: BehaviorSubject<boolean>;
+    /** Store the messages history of the current chat. */
+    chatHistory: ChatMessage[] | undefined;
+    /** List of models available on the server. */
+    models: GllmModelDescription[] | undefined;
+    /** List of functions available on the server. */
+    functions: GllmFunction[] | undefined;
+    /** List of saved chats. */
+    savedChats$: BehaviorSubject<SavedChat[]>;
+    /** Whether there is an error with saved chats. */
+    savedChatsError$: BehaviorSubject<boolean>;
+    /** Emit the saved chat to load. */
+    loadSavedChat$: BehaviorSubject<SavedChat | undefined>;
+    /** Emit the quota each time the chat is invoked. */
+    quota$: BehaviorSubject<Quota | undefined>;
+    /** Emit the calculated user's token consumption based on the quota. */
+    userTokenConsumption$: BehaviorSubject<UserTokenConsumption | undefined>;
+    /** Emit the chat usage metrics each time the generation of the assistant response is completed. */
+    chatUsageMetrics$: BehaviorSubject<ChatUsageMetrics | undefined>;
+    /** Emit the calculated chat's token consumption based on the chat usage metrics. */
+    chatTokenConsumption$: BehaviorSubject<TokenConsumption | undefined>;
+    /** Emit true if "CancelTasks" is ongoing. */
+    stoppingGeneration$: BehaviorSubject<boolean>;
+    /** Instance ID of the chat service defining the assistant instance. */
+    private _chatInstanceId;
+    /** Generated GUID for the current chat discussion used to save/get/delete it and identify audit events. */
+    private _chatId;
+    userSettingsService: UserSettingsWebService;
+    notificationsService: NotificationsService;
+    appService: AppService;
+    principalService: PrincipalService;
+    assistantUtils: AssistantUtils;
+    private savedChatsService;
+    private signalRConnectionService;
+    private assistantConfigurationService;
+    private assistantMetadataService;
+    private assistantTokensTrackingService;
+    private debugMessageService;
+    private assistantWsFramesService;
+    protected readonly transloco: TranslocoService;
+    /**
+     * Initialize the assistant process.
+     * It includes building and starting a connection, executing parallel requests for models and functions, and handling errors during the process.
+     * ⚠️ This method MUST be called ONLY if the user is loggedIn and once when the assistant is initialized.
+     *
+     * @returns An Observable<boolean> indicating the success of the initialization process.
+     */
+    init(): Observable<boolean>;
+    /**
+     * Define the endpoint to use for the websocket requests
+     * It can be overridden by the app config
+     */
+    getWSRequestsUrl(): void;
+    /**
+     * Define the endpoint to use for the http requests
+     * It can be overridden by the app config
+     */
+    getRESTRequestsUrl(): void;
+    /**
+     * Retrieves the plugin version information.
+     * @returns An Observable of PluginVersion or undefined.
+     */
+    getPluginVersion(): Observable<PluginVersion | undefined>;
+    /**
+     * Retrieves the Sinequa Enterprise Search version.
+     * @returns The Sinequa Enterprise Search version as a string, or undefined if not available.
+     */
+    getSinequaESVersion(): Observable<string | undefined>;
+    /**
+     * Checks and logs the version alignment between the Angular library, plugin, and Sinequa ES.
+     * It fetches the plugin and Sinequa ES versions in parallel and logs the information to the console.
+     */
+    checkVersionAlignment(): Observable<any>;
+    /**
+     * Initializes the SavedChatsService with the necessary configuration.
+     *
+     * This method sets up the `SavedChatsService` by providing it with a configuration object
+     * (`SavedChatsOperationConfig`) that includes various callbacks and properties required
+     * for its operation. The initialization will only proceed if both `assistantConfig$` and
+     * `REST_REQUEST_URL` are available.
+     *
+     * The configuration object includes:
+     * - Application name retrieval.
+     * - Instance ID retrieval.
+     * - REST API URL retrieval.
+     * - Debug flag retrieval.
+     * - Chat ID for new saves.
+     * - Saved chats enablement check.
+     * - Methods for setting a saved chat ID, updating the saved chats list, and generating audit events.
+     *
+     * If the required dependencies are not ready, an error is logged to the console.
+     *
+     * @private
+     */
+    private _initSavedChatsService;
+    /**
+     * Initializes the SignalR connection service with the necessary configuration.
+     *
+     * This method ensures that the SignalR connection service is properly set up
+     * by providing it with the required configuration values, such as the WebSocket
+     * request URL and assistant configuration. It also manages the SignalR hub connection
+     * instance.
+     *
+     * Preconditions:
+     * - `assistantConfig$.value` must be available.
+     * - `WS_REQUEST_URL` must be defined.
+     *
+     * If these preconditions are not met, an error is logged to the console.
+     *
+     * @private
+     */
+    private _initSignalRConnectionService;
+    /**
+     * Initializes the Assistant Configuration Service with the necessary operation context.
+     * This method sets up the configuration context by providing various utility functions
+     * and state management mechanisms required for the assistant's configuration operations.
+     *
+     * The operation context includes:
+     * - Methods to retrieve chat instance and chat IDs.
+     * - Methods to get and set assistant configuration values.
+     * - Methods to set WebSocket and REST request URLs.
+     * - Methods to update the initialization configuration status.
+     * - A method to generate audit events for tracking operations.
+     *
+     * @private
+     */
+    private _initAssistantConfigurationService;
+    /**
+     * Initializes the AssistantMetadataService with the necessary operation context.
+     *
+     * This method checks if the `assistantConfig$` value and `REST_REQUEST_URL` are available.
+     * If both are ready, it creates an `AssistantMetadataOperationContext` object and
+     * initializes the `assistantMetadataService` with it. The operation context provides
+     * methods to retrieve the REST URL, assistant configuration, and to set models and functions.
+     *
+     * If the required values are not ready, an error is logged to the console.
+     *
+     * @private
+     */
+    private _initAssistantMetadataService;
+    /**
+     * Initializes the Assistant Tokens Tracking Service with the necessary operation context.
+     * This method sets up the service by providing it with functions to manage quotas,
+     * token consumption, usage metrics, and audit events, as well as access to assistant configuration
+     * and model retrieval.
+     *
+     * The initialization will only proceed if the assistant configuration is available.
+     * If the configuration is not ready, an error message is logged to the console.
+     *
+     * @private
+     */
+    private _initAssistantTokensTrackingService;
+    /**
+     * Initializes the Assistant WebSocket Frames Service with the necessary operation context.
+     * This method sets up the required dependencies and configuration for the service to function properly.
+     * It ensures that the assistant configuration and connection are available before initializing the service.
+     *
+     * The operation context provides various utility functions and state management methods, including:
+     * - Accessing the assistant configuration, chat instance ID, saved chat ID, and chat history.
+     * - Managing streaming and stopping generation statuses.
+     * - Updating quota and chat usage metrics.
+     * - Generating audit events.
+     * - Managing saved chats (adding, updating, and listing).
+     *
+     * If the required dependencies (`assistantConfig$` and `connection`) are not ready, an error is logged.
+     *
+     * @private
+     */
+    private _initAssistantWsFramesService;
+    private _initDebugMessageService;
+    get assistants(): any;
+    /**
+     * Get the instance ID of the chat service
+     * @returns The instance ID of the chat service
+     */
+    get chatInstanceId(): string;
+    /**
+     * Persist the instance ID of the chat service
+     * @param instanceId The instance ID of the chat service
+     */
+    setChatInstanceId(instanceId: string): void;
+    /**
+     * Get the ID of the current chat discussion which is used to save/get/delete the discussion and identify audit events
+     * @returns The ID of the current chat discussion
+     */
+    get chatId(): string;
+    /**
+     * Generate an GUID for the current chat discussion which is used to save/get/delete it and identify audit events
+     * @param chatId if provided, it will be considered as the ID of the current chat discussion which is used to identify audit events
+     */
+    generateChatId(chatId?: string): void;
+    /**
+     * Initialize the chat config by managing ONLY sub-object **defaultValues** configs of the standard app config (defined in the customization json tab ) and the user preferences.
+     * To do so, a tracking mechanism is implemented to notify the user about the available updates in the defaultValues object of the standard app config.
+     * The rest of the config object coming from "standard app config" is used as it is without any override.
+     * Thus, the user preferences are used only for the defaultValues object.
+     * This provide a centralized way to manage the rest of the config object by admins and ensure a unique common behavior for all users.
+     */
+    initChatConfig(): Promise<void>;
+    /**
+     * Update the chat config and store its defaultValues in the user preferences
+     * @param config  The updated chat config
+     * @param hashes  The updated hashes to store in the user preferences
+     * @param notify  Whether to notify the user about the update
+     * @param successCallback  The callback to execute if the update is successful
+     * @param errorCallback  The callback to execute if the update fails
+     */
+    updateChatConfig(config: ChatConfig, hashes?: {
+        "applied-defaultValues-hash"?: string;
+        "skipped-defaultValues-hash"?: string;
+    }, notify?: boolean, successCallback?: () => any, errorCallback?: () => any): void;
+    /**
+     * Overrides the logged in user
+     */
+    overrideUser(): void;
+    /**
+     * Calls the Fetch API to retrieve a new message given all previous messages
+     */
+    fetch(messages: ChatMessage[], query: Query): Observable<ChatResponse>;
+    /**
+     * Return the list of models available on the server
+     */
+    listModels(): Observable<GllmModelDescription[] | undefined>;
+    /**
+     * Return the list of functions available on the server AND matching enabled functions in the chat config
+     */
+    listFunctions(): Observable<GllmFunction[] | undefined>;
+    /**
+     * Stops the assistant answer generation and cancels all the ongoing and pending related tasks
+     */
+    stopGeneration(): Observable<boolean>;
+    /**
+     * A handler for quota updates each time the chat is invoked.
+     * It emits the updated quota to the quota$ subject, emits accordingly the updated user's tokens consumption and notifies the user if the max quota is reached.
+     * @param quota The updated quota
+     * @param propagateError Whether to propagate the error to the caller
+     */
+    updateQuota(quota: Quota, propagateError?: boolean): void;
+    /**
+     * A handler for chat usage metrics each time the generation of the assistant response is completed.
+     * It emits the chat usage metrics to the chatUsageMetrics$ subject, emits accordingly the updated chat's tokens consumption
+     * @param chatUsageMetrics The chat usage metrics
+     */
+    updateChatUsageMetrics(chatUsageMetrics: ChatUsageMetrics): void;
+    /**
+     * Get the model description for the given (serviceId + modelId)
+     * If a model is not found, an error message is returned
+     * @param serviceId The serviceId of the model
+     * @param modelId The modelId of the model
+     * @returns The model description
+     */
+    getModel(serviceId: string, modelId: string): GllmModelDescription | undefined;
+    /**
+     * Fetch the list saved chats belonging to a specific instance of the assistant
+     */
+    listSavedChat(): void;
+    /**
+     * Return the saved chat with the given id, if exists. Otherwise, return undefined
+     * @param id The id of the saved chat
+     */
+    getSavedChat(id: string): Observable<SavedChatHistory | undefined>;
+    /**
+     * Check if a saved chat with the given id already exists
+     * @param id The id of the saved chat
+     * @returns True if the saved chat exists, false otherwise
+     */
+    isExistingSavedChat(id: string): Observable<boolean>;
+    /**
+     * Save a chat with the given messages
+     * @param messages The messages to add to the saved chat index
+     * @returns The saved chat
+     */
+    addSavedChat(id: string, messages: ChatMessage[]): Observable<SavedChatResponse>;
+    /**
+     * Update a saved chat with the given id.
+     * @param id The id of the saved chat
+     * @param name The new name of the saved chat, if provided
+     * @param messages The messages to update the saved chat history, if provided
+     * @returns True if the saved chat has been successfully updated
+     */
+    updateSavedChat(id: string, name?: string, messages?: ChatMessage[]): Observable<SavedChatResponse>;
+    /**
+     * Bulk delete of saved chats matching the given ids
+     * @param ids List of ids of the saved chats to delete
+     * @returns The number of deleted chats
+     */
+    deleteSavedChat(ids: string[]): Observable<DeleteSavedChatResponse>;
+    getDebugMessage(message: DebugMessage): Observable<KvObject | ListObject | undefined>;
+    /**
+     * Initialize out-of-the-box handlers
+     * It is a placeholder for non-streaming scenarios, where you invoke a specific hub method, and the server responds with frame message(s)
+     */
+    initMessageHandlers(): void;
+    /**
+     * Override and register the entire _messageHandlers map by merging the provided map with the default one
+     * @param _messageHandlers
+     */
+    overrideMessageHandlers<T>(_messageHandlers: Map<string, MessageHandler<T>>): void;
+    /**
+     * Add a listener for a specific event.
+     * If a listener for this same event already exists, it will be overridden.
+     * If the listener has "isGlobalHandler" set to true, it will be registered to the hub connection.
+     * @param eventName Name of the event to register a listener for
+     * @param eventHandler The handler to be called when the event is received
+     */
+    addMessageHandler<T>(eventName: string, eventHandler: MessageHandler<T>): void;
+    /**
+     * Remove a listener for a specific event from the _messageHandlers map and unsubscribe from receiving messages for this event from the SignalR hub.
+     * @param eventName Name of the event to remove the listener for
+     */
+    removeMessageHandler(eventName: string): void;
+    /**
+     * Build a connection to the signalR websocket and register default listeners to the methods defined in the server hub class
+     * @param options The options for the connection. It overrides the default options
+     * @param logLevel Define the log level displayed in the console
+     * @returns Promise that resolves when the connection is built
+     */
+    buildConnection(options?: ConnectionOptions): Promise<void>;
+    /**
+     * Start the connection
+     * @returns Promise that resolves when the connection is started
+     */
+    startConnection(): Promise<void>;
+    /**
+     * Stop the connection
+     * @returns Promise that resolves when the connection is stopped
+     */
+    stopConnection(): Promise<void>;
+    /**
+     * Generate an audit event with the given type and details. The generated audit event is sent afterwards via the AuditWebService
+     * @param type Audit event type
+     * @param details Audit event details
+     * @param id Actions (savedChat delete/rename/...) may occur on a specific chat different than the current one stored in this service, so the chat id can be provided
+     */
+    generateAuditEvent(type: string, details: Record<string, any>, id?: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatService>;
+}
+
+/**
+ * A service to create and manage instances of ChatService dynamically based on the provided component references and the implementation type (http or websocket)
+ * All chat-related components should share the same instance of this InstanceManagerService, which in turn provides the appropriate instance of ChatService
+ */
+declare class InstanceManagerService {
+    private _serviceInstances;
+    /**
+     * Store the instance of ChatService in the map
+     * @param key key differentiator between components used to store their corresponding ChatService instance
+     * @param service The ChatService instance
+     */
+    storeInstance(key: string, service: ChatService): void;
+    /**
+     * @param key key differentiator between components based on which the corresponding ChatService instance is fetched
+     * @returns The instance of the service corresponding to the instance of the component
+     */
+    getInstance(key: string): ChatService;
+    /**
+     *
+     * @param key key differentiator between components based on which the check for an existent ChatService instance is performed
+     * @returns True if a ChatService instance has been already instantiated for the given key. Otherwise, false.
+     */
+    checkInstance(key: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InstanceManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InstanceManagerService>;
+}
+
+declare class ChatSettingsV3Component implements OnInit, OnDestroy {
+    /** Define the key based on it, the appropriate chatService instance will be returned from instanceManagerService */
+    instanceId: string;
+    _update: EventEmitter<ChatConfig>;
+    _cancel: EventEmitter<ChatConfig>;
+    chatService: ChatService;
+    config: ChatConfig;
+    subscription: Subscription;
+    selectedModel: GllmModelDescription | undefined;
+    functions: {
+        name: string;
+        enabled: boolean;
+    }[];
+    isAdmin: boolean;
+    showDebugToggle: boolean;
+    instanceManagerService: InstanceManagerService;
+    principalService: PrincipalService;
+    appService: AppService;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get hasPrompts(): boolean;
+    get hasAdvancedParameters(): boolean;
+    get hasModel(): boolean;
+    instantiateChatService(): void;
+    onChatModelChange(selectedModel: GllmModelDescription): void;
+    getFunctionDescription(name: string): string;
+    toggleFunctionsSelection(name: string): void;
+    private initFunctionsList;
+    /**
+     * Save the new chat config in the chat service and the user preferences
+     * If the user has never modified the default values, we need to save the hash of the standard default values, as defined by the admin, in order to properly track changes afterwards.
+     */
+    save(): Promise<void>;
+    /**
+     * Cancel the current changes
+     */
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatSettingsV3Component, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChatSettingsV3Component, "sq-chat-settings-v3", never, { "instanceId": { "alias": "instanceId"; "required": false; }; }, { "_update": "update"; "_cancel": "cancel"; }, never, never, true, never>;
+}
+
+declare class SearchService {
+    query: Query;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchService>;
+}
+
+declare class ChatComponent implements OnInit, OnChanges, OnDestroy {
+    chatService: ChatService;
+    instanceManagerService: InstanceManagerService;
+    searchService: SearchService;
+    principalService: PrincipalService;
+    cdr: ChangeDetectorRef;
+    notificationsService: NotificationsService;
+    private readonly transloco;
+    private readonly assistantUtils;
+    private destroyRef;
+    /** Define the key based on it, the chat service instance will be stored */
+    instanceId: string;
+    /** Define the query to use to fetch answers */
+    query: Query;
+    /** Function that determines whether the chat should be reloaded after the query changes
+     * If not provided, the chat will be reloaded by default
+     * @param prevQuery The previous query
+     * @param newQuery The new query
+     * @returns true if the chat should be reloaded, false otherwise
+     */
+    queryChangeShouldTriggerReload: (prevQuery: Query, newQuery: Query) => boolean;
+    /** Map of listeners overriding default registered ones*/
+    messageHandlers: Map<string, MessageHandler<any>>;
+    /** When the assistant answer a user question, automatically scroll down to the bottom of the discussion */
+    automaticScrollToLastResponse: boolean;
+    /** When the assistant answer a user question, automatically focus to the chat input */
+    focusAfterResponse: boolean;
+    /** A chat discussion that the component should get initialized with it */
+    chat?: InitChat;
+    /** Icon to use for the assistant messages */
+    assistantMessageIcon: string;
+    /** Icon to use for the user messages */
+    userMessageIcon: string;
+    /** Icon to use for the connection error messages */
+    connectionErrorMessageIcon: string;
+    /** Icon to use for the search warning messages */
+    searchWarningMessageIcon: string;
+    additionalWorkflowProperties: Record<string, any>;
+    /** Used by assistant web component to pass properly init the global config */
+    appConfig: AppGlobalConfig;
+    /** Whether the chat component is displayed in a collapsed state */
+    collapsed: boolean;
+    /** Event emitter triggered once the signalR connection is established  */
+    connection: EventEmitter<HubConnection>;
+    /** Event emitter triggered each time the assistant updates the current chat */
+    /** Event emitter triggered when the chat is loading new content */
+    loading$: EventEmitter<boolean>;
+    /** Emits the assistant configuration used when instantiating the component */
+    _config: EventEmitter<ChatConfig>;
+    data: EventEmitter<ChatMessage[]>;
+    /** Event emitter triggered when the user clicks to open the original document representing the context attachment*/
+    openDocument: EventEmitter<Article>;
+    /** Event emitter triggered when the user clicks to open the preview of a document representing the context attachment */
+    openPreview: EventEmitter<ChatContextAttachment>;
+    /** Event emitter triggered when the user clicks on a suggested action */
+    suggestAction: EventEmitter<SuggestedAction>;
+    /** ViewChild decorators to access the template elements */
+    questionInput?: ElementRef<HTMLTextAreaElement>;
+    /** ContentChild decorators allowing the override of the default templates from the parent component */
+    loadingTpl?: TemplateRef<any>;
+    reportTpl?: TemplateRef<any>;
+    tokenConsumptionTpl?: TemplateRef<any>;
+    debugMessagesTpl?: TemplateRef<any>;
+    config: ChatConfig;
+    messages$: BehaviorSubject<ChatMessage[] | undefined>;
+    isAdminOrDeletedAdmin: boolean;
+    question: string;
+    private _dataSubscription;
+    /** Variables that depend on the type of model in use */
+    modelDescription?: GllmModelDescription;
+    indexMessageToEdit?: number;
+    rankMessageToEdit?: number;
+    changes$: BehaviorSubject<SimpleChanges | undefined>;
+    currentMessageIndex: number | undefined;
+    firstChangesHandled: boolean;
+    isAtBottom: boolean;
+    initializationError: boolean;
+    enabledUserInput: boolean;
+    isConnected: boolean;
+    retrialAttempts: number | undefined;
+    private _isReconnectedListenerRegistered;
+    issueTypes?: string[];
+    defaultIssueTypes: string[];
+    issueType: string;
+    reportComment?: string;
+    messageToReport?: ChatMessage;
+    reportRank?: number;
+    reportType: 'like' | 'dislike';
+    showReport: boolean;
+    debugMessages: DebugMessage[] | undefined;
+    showDebugMessages: boolean;
+    private _previousQuery;
+    private _reloadSubscription;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    get isAdmin(): boolean;
+    /**
+     * This chat service instance is stored in the instanceManagerService with provided @input instanceId as a key
+     */
+    instantiateChatService(): void;
+    /**
+     * Handles the changes in the chat component.
+     * If the chat service is a WebSocketChatService, it handles the override of the message handlers if they exist.
+     * Initializes the chat with the provided chat messages if they exist, otherwise loads the default chat.
+     * If the chat is initialized, the initialization event is "Query", the query changes, and the queryChangeShouldTriggerReload function is provided,
+     * then the chat should be reloaded if the function returns true. Otherwise, the chat should be reloaded by default.
+     * It takes into account the ongoing streaming process and the ongoing stopping process to trigger that conditionally define the logic
+     * of the reload :
+     * - If the chat is streaming, then stop the generation and wait for the fetch to complete before reloading the chat.
+     * - If the chat is stopping the generation, then wait for the fetch to complete before reloading the chat.
+     */
+    private _handleChanges;
+    /**
+     * Triggers a reload after the query change.
+     * This method performs the necessary operations to reload the chat after a query change.
+     * It sets the system and user messages, resets the savedChatId, generates a new chatId,
+     * generates a new chat audit event, and handles the query mode.
+     */
+    private _triggerReloadAfterQueryChange;
+    /**
+     * Adds a scroll listener to the message list element.
+     * The listener is triggered when any of the following events occur:
+     * - Loading state changes
+     * - Messages change
+     * - Streaming state changes
+     * - Scroll event occurs on the message list element
+     *
+     * When the listener is triggered, it updates the `isAtBottom` property.
+     */
+    private _addScrollListener;
+    /**
+     * Get the model description based on the defaultValues service_id and model_id
+     */
+    updateModelDescription(): void;
+    /**
+     * Submits a question from the user.
+     * If the user is editing a previous message, removes all subsequent messages from the chat history.
+     * Triggers the fetch of the answer for the submitted question by calling _fetchAnswer().
+     * Clears the input value in the UI.
+     * ⚠️ If the chat is streaming or stopping the generation, the operation is not allowed.
+     */
+    submitQuestion(): void;
+    /**
+     * Triggers the fetch of the answer for the given question and updates the conversation.
+     * Generates an audit event for the user input.
+     *
+     * @param question - The question asked by the user.
+     * @param conversation - The current conversation messages.
+     */
+    private _fetchAnswer;
+    /**
+     * Depending on the connection's state :
+     *  - If connected => given a list of messages, the chat endpoint is invoked for a continuation and updates the list of messages accordingly.
+     *  - If any other state => a connection error message is displayed in the chat.
+     * ⚠️ If the assistant is streaming or stopping the generation, the operation is not allowed.
+     * @param messages The list of messages to invoke the chat endpoint with
+     */
+    fetch(messages: ChatMessage[]): void;
+    /**
+     * Retry to fetch the messages if the connection issues.
+     *  - If reconnecting => keep display the connection error message even when clicking on the "retry" button and increasing the number of retrial attempts, until the connection is re-established
+     *  - If disconnected => On click on the "retry" button, start the connection process while displaying the connection error message :
+     *      * If successful => given a list of messages, the chat endpoint is invoked for a continuation and updates the list of messages accordingly.
+     *      * If failed => increase the number of retrial attempts
+     */
+    retryFetch(): void;
+    /**
+     * Check if the signalR connection is connected.
+     * For the REST protocol, the connection is always considered connected (for the moment).
+     */
+    private _updateConnectionStatus;
+    /**
+     * Update the UI with the new messages
+     * @param messages
+     */
+    updateData(messages: ChatMessage[]): void;
+    /**
+     * @returns true if the chat discussion is scrolled down to the bottom, false otherwise
+     */
+    private _toggleScrollButtonVisibility;
+    /**
+     * Scroll down to the bottom of the chat discussion
+     */
+    scrollDown(): void;
+    /**
+     * Start a new chat with the defaultValues settings.
+     * The savedChatId in the chat service will be reset, so that the upcoming saved chat operations will be performed on the fresh new chat.
+     * If the savedChat feature is enabled, the list of saved chats will be refreshed.
+     * ⚠️ If the assistant is streaming or stopping the generation, the operation is not allowed.
+     */
+    newChat(): void;
+    /**
+     * Attaches the specified document IDs to the assistant.
+     * If no document IDs are provided, the operation is not allowed.
+     * If the action for attaching a document is not defined at the application customization level, an error is logged.
+     * ⚠️ If the assistant is streaming or stopping the generation, the operation is not allowed.
+     * @param ids - An array of document IDs to attach.
+     */
+    attachToChat(ids: string[]): void;
+    /**
+     * Start the default chat with the defaultValues settings
+     * If the chat is meant to be initialized with event === "Query", the corresponding user query message will be added to the chat history
+     */
+    loadDefaultChat(): void;
+    /**
+     * Handles the prompt mode of the chat component.
+     * If `sendUserPrompt` is true, it opens the chat with both system and user messages,
+     * and generates audit events for both messages.
+     * If `sendUserPrompt` is false, it opens the chat with only the system message,
+     * and generates an audit event for the system message.
+     *
+     * @param systemMsg - The system message to be displayed in the chat.
+     * @param userMsg - The user message to be displayed in the chat (optional).
+     */
+    private _handlePromptMode;
+    /**
+     * Handles the query mode by displaying the system message, user message, and user query message.
+     * If the provided query text is not empty, then add the user query message to the chat history and invoke the assistant
+     * Otherwise, just start a new chat with a warning message inviting the user to perform a full text search to retrieve some results
+     * @param systemMsg - The system message to be displayed.
+     * @param userMsg - The user message to be displayed.
+     */
+    private _handleQueryMode;
+    private _defineMessageAuditDetails;
+    /**
+     * Start/open a new chat with the provided messages and chatId
+     * If the last message is from the user, a request to the assistant is made to get an answer
+     * If the last message is from the assistant, the conversation is loaded right away
+     * @param messages The list of messages of the chat
+     * @param chatId  The id of the discussion. If provided (ie. an existing discussion in the saved chat index), update the chatId in the chat service for the upcoming saved chat operations
+     */
+    openChat(messages: RawMessage[], chatId?: string): void;
+    /**
+     * Reset the chat by clearing the chat history and the UI accordingly
+     * The user input will be cleared
+     * The fetch subscription will be terminated
+     */
+    resetChat(): void;
+    /**
+     * Fetch and Load the saved chat from the saved chat index.
+     * If the saved chat is found, the chat discussion will be loaded with the provided messages and chatId
+     */
+    onLoadChat(): void;
+    /**
+     * Stop the generation of the current assistant's answer.
+     * The fetch subscription will be terminated.
+     */
+    stopGeneration(): void;
+    /**
+     * Terminate the fetch process by unsubscribing from the data subscription and updating the loading status to false.
+     * Additionally, focus on the chat input if the focusAfterResponse flag is set to true.
+     */
+    terminateFetch(): void;
+    /**
+     * Copy a previous user message of the chat history to the chat user input.
+     * Thus, the user can edit and resubmit the message.
+     * Once the edited message is submitted, all subsequent messages starting from @param index will be removed from the history and the UI will be updated accordingly.
+     * The assistant will regenerate a new answer based on the updated chat history.
+     * ⚠️ If the assistant is streaming or stopping the generation, the operation is not allowed.
+     * @param message The user's message to edit
+     * @param index The index of the user's message to edit
+     * @returns void
+     */
+    editMessage(message: ChatMessage, index: number): void;
+    /**
+     * Copy a previous assistant message of the chat history to the clipboard.
+     * @param message The message to copy
+     * @param index The index of the message to copy
+     * @returns void
+     */
+    copyMessage(message: ChatMessage, index: number): void;
+    /**
+     * Starting from the provided index, remove all subsequent messages from the chat history and the UI accordingly.
+     * The assistant will regenerate a new answer based on the updated chat history.
+     * ⚠️ If the assistant is streaming or stopping the generation, the operation is not allowed.
+     * @param message The assistant's message to regenerate
+     * @param index The index of the assistant's message to regenerate
+     */
+    regenerateMessage(message: ChatMessage, index: number): void;
+    /**
+     * Handles the key up event for 'Backspace' and 'Enter' keys.
+     * @param event - The keyboard event.
+     */
+    onKeyUp(event: KeyboardEvent): void;
+    /**
+     * Calculates and adjusts the height of the question input element based on its content.
+     * If the Enter key is pressed without the Shift key, it prevents the default behavior.
+     * @param event The keyboard event
+     */
+    calculateHeight(event?: KeyboardEvent): void;
+    /**
+     * Send a "like" event on clicking on the thumb-up icon of an assistant's message
+     * @param message The assistant message to like
+     * @param index The index of the message to like
+     */
+    onLike(message: ChatMessage, index: number): void;
+    /**
+     * Send a "dislike" event on clicking on the thumb-down icon of an assistant's message.
+     * It also opens the issue reporting dialog.
+     * @param message The assistant message to dislike
+     * @param index The rank of the message to dislike
+     */
+    onDislike(message: ChatMessage, index: number): void;
+    private _updateChatHistory;
+    /**
+     * Report an issue related to the assistant's message.
+     */
+    sendReport(): void;
+    /**
+     * Close the reporting dialog.
+     */
+    ignoreReport(): void;
+    /**
+     * Handle the click on a reference's 'open preview'.
+     * @param data
+     * @param message the message containing the reference
+     * @param index index of the message containing the reference
+     * @returns void
+     */
+    openAttachmentPreview(data: {
+        reference: ChatContextAttachment;
+        partId?: number;
+    }, message: ChatMessage, index: number): void;
+    /**
+     * Handle the click on a reference's 'open original document'.
+     * @param data
+     * @param message the message containing the reference
+     * @param index index of the message containing the reference
+     * @returns void
+     */
+    openOriginalAttachment(data: {
+        reference: ChatContextAttachment;
+        partId?: number;
+    }, message: ChatMessage, index: number): void;
+    /**
+     * Handle the click on a suggested action.
+     * @param action Suggested action.
+     * @param index index of the message containing the suggested action.
+     * @returns void
+     */
+    suggestActionClick(action: SuggestedAction, index: number): void;
+    /**
+     * It looks for the debug messages available in the current group of "assistant" messages.
+     * By design, the debug messages are only available in the first visible message among the group of "assistant" messages.
+     * @param message The message containing the debug information
+     * @param index The index of the message
+     * @returns The debug messages available in the current group of "assistant" messages
+     */
+    getDebugMessages(message: ChatMessage, index: number): DebugMessage[];
+    /**
+     * Handle the click on the 'show log info' button of a message.
+     * @param message The message containing the debug information
+     * @param index The index of the message
+     */
+    showDebug(message: ChatMessage, index: number): void;
+    /**
+     * Verify whether the current message is an assistant message and that all following messages are assistant ones
+     * Used to keep the "View progress" opened even though the assistant is sending additional messages after the current one
+     * @param messages the list of current messages
+     * @param index the index of the current message
+     * @returns if this messages and the following ones (if any) are the last ones
+     */
+    isAssistantLastMessages(messages: ChatMessage[], index: number): boolean;
+    /**
+     * Checks if the given message is an empty assistant message.
+     * An empty assistant message is defined as a message with the role 'assistant',
+     * an empty content, and no additional properties such as attachments, progress,
+     * debug information, or suggested actions.
+     *
+     * @param message - The message to check.
+     * @returns `true` if the message is an empty assistant message, `false` otherwise.
+     */
+    isEmptyAssistantMessage(message: ChatMessage | undefined): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChatComponent, "sq-chat-v3", never, { "instanceId": { "alias": "instanceId"; "required": false; }; "query": { "alias": "query"; "required": false; }; "queryChangeShouldTriggerReload": { "alias": "queryChangeShouldTriggerReload"; "required": false; }; "messageHandlers": { "alias": "messageHandlers"; "required": false; }; "automaticScrollToLastResponse": { "alias": "automaticScrollToLastResponse"; "required": false; }; "focusAfterResponse": { "alias": "focusAfterResponse"; "required": false; }; "chat": { "alias": "chat"; "required": false; }; "assistantMessageIcon": { "alias": "assistantMessageIcon"; "required": false; }; "userMessageIcon": { "alias": "userMessageIcon"; "required": false; }; "connectionErrorMessageIcon": { "alias": "connectionErrorMessageIcon"; "required": false; }; "searchWarningMessageIcon": { "alias": "searchWarningMessageIcon"; "required": false; }; "additionalWorkflowProperties": { "alias": "additionalWorkflowProperties"; "required": false; }; "appConfig": { "alias": "appConfig"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; }, { "connection": "connection"; "loading$": "loading"; "_config": "config"; "data": "data"; "openDocument": "openDocument"; "openPreview": "openPreview"; "suggestAction": "suggestAction"; }, ["loadingTpl", "reportTpl", "tokenConsumptionTpl", "debugMessagesTpl"], never, true, never>;
+}
+
+declare class SavedChatsComponent implements OnInit, OnDestroy {
+    /** Define the key based on it, the appropriate chatService instance will be returned from instanceManagerService */
+    instanceId: string;
+    load: EventEmitter<SavedChat>;
+    delete: EventEmitter<SavedChat>;
+    chatService: ChatService;
+    subscription: Subscription;
+    groupedSavedChats$: BehaviorSubject<{
+        key: string;
+        value: SavedChat[];
+    }[]>;
+    queryWebserviceForSearch?: string;
+    private searchQuery;
+    private searchText;
+    private searchText$;
+    instanceManagerService: InstanceManagerService;
+    notificationsService: NotificationsService;
+    private readonly transloco;
+    private readonly assistantUtils;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onSearch(event: Event): void;
+    instantiateChatService(): void;
+    onListSavedChat(): void;
+    onLoad(savedChat: SavedChat): void;
+    private _groupSavedChatsByDate;
+    private searchSavedChats;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SavedChatsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SavedChatsComponent, "sq-saved-chats-v3", never, { "instanceId": { "alias": "instanceId"; "required": false; }; }, { "load": "load"; "delete": "delete"; }, never, never, true, never>;
+}
+
+declare class InitialsAvatarComponent {
+    fullName: string;
+    size: number;
+    /**
+       * Gives initials of a name and a safe color background to use,
+       * assuming text color will be white
+       * @param fullName full name to evaluate intials for
+       * @param split string to use has splitter for `fullName`
+       * @returns an `object` containing initials and color
+       */
+    getInitialsAndColorFromFullName(fullName: string, split?: string): {
+        initials: string;
+        color: string;
+    };
+    /**
+     * Gives initials of a name, ie:
+     * ```
+     * getInitialForFullName('John Snow') => 'JS'
+     * getInitialForFullName('Geralt of Rivia', ' of ') => 'GR'
+     * ```
+     * @param fullName full name to evaluate intial for
+     * @param split string to use has splitter
+     * @returns string containg the first letter of splitted name
+     */
+    getInitialsFromFullName(fullName: string, split?: string): string;
+    /**
+     * Gets a random color using text as seed
+     * @param text string to use for color generation
+     * @returns string formatted like `rgb(xxx, xxx, xxx)`
+     */
+    getColorFromName(text: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitialsAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InitialsAvatarComponent, "sq-initials-avatar", never, { "fullName": { "alias": "fullName"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FormatIconComponent implements OnChanges {
+    extension: string;
+    private _formatIcons;
+    icon: string;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormatIconComponent, "sq-format-icon", never, { "extension": { "alias": "extension"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type UploadConfig = {
+    documentsUploadEnabled: boolean;
+    constraints: {
+        maxTotalFileSizeMB: number;
+        remainingFileSizeMB: number;
+        maxTotalFileCount: number;
+        remainingFileCount: number;
+        supportedFileExtensions: string[];
+    };
+};
+type UploadResponse = {
+    statusToken: string;
+    executionTime: string;
+    connectorResponse?: {
+        collection: string;
+        action: string;
+        stats: {
+            nbDocUpdated: number;
+        };
+    };
+};
+type UploadingInfos = {
+    loaded: number;
+    total: number;
+    progress: number;
+};
+type UploadProgressEvent = {
+    type: 'uploadProgress';
+} & UploadingInfos;
+interface UploadResponseEvent {
+    type: 'response';
+    body: UploadResponse;
+}
+type UploadEvent = UploadProgressEvent | UploadResponseEvent;
+type IndexingInfos = {
+    docs: {
+        id: string;
+        fileName: string;
+        operation: "Add" | "Update";
+        status: "Indexing" | "Indexed" | "Error";
+        previousIndexationTime: string | null;
+        currentIndexationTime: string | null;
+    }[];
+    isCompleted: boolean;
+    executionTime: string;
+};
+interface UploadedDocuments {
+    docs: UploadedDocument[];
+    count: number;
+    totalCount: number;
+    executionTime: string;
+}
+interface UploadedDocument {
+    id: string;
+    fileName: string;
+    title: string;
+    fileExt: string;
+    indexationTime: string;
+    size: string;
+    sizeDisplay: string;
+    [key: string]: any;
+}
+interface deleteDocumentsResponse {
+    deletedCount: number;
+    executionTime: string;
+}
+
+declare class DocumentsUploadService {
+    readonly REQUEST_URL = "api/v1/plugin/SinequaAssistantREST";
+    /** Documents upload configuration. */
+    uploadConfig$: BehaviorSubject<UploadConfig | undefined>;
+    /** Emit the list of indexed documents */
+    uploadedDocuments$: BehaviorSubject<UploadedDocument[] | undefined>;
+    appService: AppService;
+    http: HttpClient;
+    /**
+     * Initializes the file upload service.
+     */
+    init(): void;
+    /**
+     * Retrieves the upload configuration for documents.
+     * The response, which contains the upload configuration, is emitted to the `uploadConfig$` observable.
+     *
+     * @throws {Error} If there is an error invoking the `documentsUploadConfigGet` action.
+     */
+    getUploadConfig(): void;
+    /**
+     * Uploads documents to the server.
+     *
+     * This method takes a FormData object which should contain all files to be uploaded.
+     * Each file should be appended to the FormData object with its original name.
+     *
+     * For example:
+     * ```typescript
+     * const formData = new FormData();
+     * formData.append(file.name, file.file);
+     * ```
+     *
+     * @param formData - The FormData object containing the files to be uploaded.
+     * - Each file should be appended to the FormData object with its original name.
+     * For example:
+     * ```typescript
+     * const formData = new FormData();
+     * formData.append(file.name, file.file);
+     * ```
+     *
+     * @param enableProgress - (Optional) A boolean parameter that controls whether progress reporting is enabled.
+     * - Defaults to `true`.
+     * - If `true`, the `reportProgress` option is set in the request options, enabling the track of upload progress based on the underlying browser's progress events.
+     * - If `false`, progress events are not reported.
+     *
+     * @returns An Observable that emits events of type `UploadEvent`:
+     * - `UploadProgressEvent`: Emitted during the upload process, containing:
+     *   - *  `type`: "uploadProgress" - The type of the event.
+     *   - *  `loaded`: number - The number of bytes uploaded so far.
+     *   - *  `total`: number - The total number of bytes to be uploaded (if available).
+     *   - *  `progress`: number - The percentage of upload progress (calculated as `(loaded / total) * 100`).
+     * - `UploadResponseEvent`: Emitted when the upload is complete, containing:
+     *   - *  `type`: "response" - The type of the event.
+     *   - *  `body`: `UploadResponse` - The server's response, including:
+     *     - * - * `statusToken`: string - A token to track the status of the indexing process.
+     *     - * - *  `executionTime`: string - The time taken to execute the upload.
+     *     - * - *  `connectorResponse` (optional): Additional response data from the connector, containing:
+     *       - * - * - *  `collection`: string - The collection name.
+     *       - * - * - *  `action`: string - The action performed.
+     *       - * - * - *  `stats`: object - Statistics about the upload, including:
+     *         - * - * - * - * `nbDocUpdated`: number - The number of documents updated.
+     *
+     * @throws {Error} If there is an error invoking the `documentsupload` action.
+     *
+     * Example usage:
+     * ```typescript
+     * const formData = new FormData();
+     * formData.append(file.name, file.file);
+     * this.documentsUploadService.uploadDocuments(formData).subscribe(event => {
+     *   if (event.type === 'uploadProgress') {
+     *     console.log(`Progress: ${event.progress}%`);
+     *   } else if (event.type === 'response') {
+     *     console.log('Upload complete:', event.body);
+     *   }
+     * });
+     * ```
+     */
+    uploadDocuments(formData: FormData, enableProgress?: boolean): Observable<UploadEvent>;
+    /**
+     * Retrieves the indexing status of a predefined uploaded document(s)
+     * based on the provided status token returned from the upload process.
+     *
+     * @param token - The status token used to track the indexing process.
+     * @returns An Observable that emits the server response of type `IndexingResponse`.
+     * The `IndexingResponse` object contains:
+     * - `docs`: array - An array of document status objects, each containing:
+     *   - * `id`: string - The document ID.
+     *   - * `fileName`: string - The name of the file.
+     *   - * `operation`: "Add" | "Update" - The operation performed on the document.
+     *   - * `status`: "Indexing" | "Indexed" | "Error" - The status of the document.
+     *   - * `previousIndexationTime`: string | null - The previous indexation time.
+     *   - * `currentIndexationTime`: string | null - The current indexation time.
+     * - `executionTime`: string - The time taken to retrieve the indexing status.
+     * @throws {Error} If there is an error invoking the `documentsUploadStatus` action.
+     */
+    getIndexingStatus(token: string): Observable<IndexingInfos>;
+    /**
+     * Retrieves a list of uploaded documents.
+     *
+     * @param {string[]} [columns] - Optional array of additional index columns to include for each document.
+     * @param {number} [skip] - Optional number of documents to skip for pagination. If set, count also needs to be set. No skip if not set.
+     * @param {number} [count] - Optional number of documents to take for pagination (unlimited if not set).
+     * @returns {Observable<UploadedDocuments>} An observable that emits the list of uploaded documents.
+     * The `UploadedDocuments` object contains:
+     * - `docs`: array - An array of objects representing a single document with the following properties:
+     *   - * `id`: string - A unique identifier for the document.
+     *   - * `fileName`: string - The name of the file.
+     *   - * `title`: string - The title of the document.
+     *   - * `fileExt`: string - The file extension of the document.
+     *   - * `indexationTime`: string - The time when the document was indexed.
+     *   - * `size`: number - The size of the document.
+     *   - * `sizeDisplay`: string - A human-readable representation of the document size.
+     *   - * `[key: string]`: any - Additional columns asked in the request, value of the column for the document.
+     * - `count`: number - The count of documents in the current batch or subset.
+     * - `totalCount`: number - The total count of documents available.
+     * - `executionTime`: string - The time taken to process the documents.
+     * @throws {Error} Throws an error if the request fails.
+     */
+    getDocumentsList(columns?: string[], skip?: number, count?: number): Observable<UploadedDocuments>;
+    /**
+     * Deletes the uploaded documents with the specified IDs.
+     *
+     * @param docIds - An array of document IDs to delete.
+     * @returns An observable that emits the server response of type `deleteDocumentsResponse`.
+     * The `deleteDocumentsResponse` object contains:
+     * - `deletedCount`: number - The number of deleted documents.
+     * - `executionTime`: string - The time taken to delete the documents.
+     * @throws {Error} If there is an error invoking the `documentsDelete` action.
+     */
+    deleteDocuments(docIds: string[]): Observable<deleteDocumentsResponse>;
+    /**
+     * Deletes all uploaded documents.
+     *
+     * @returns An observable that emits the server response of type `deleteDocumentsResponse`.
+     * The `deleteDocumentsResponse` object contains:
+     * - `deletedCount`: number - The number of deleted documents.
+     * - `executionTime`: string - The time taken to delete the documents.
+     * @throws {Error} If there is an error invoking the `documentsDeleteAll` action.
+     */
+    deleteAllDocuments(): Observable<deleteDocumentsResponse>;
+    /**
+     * Formats the given file size in bytes into a human-readable string.
+     *
+     * @param bytes - The size of the file in bytes.
+     * @returns A string representing the file size in a human-readable format (e.g., "10.24 KB", "1.00 MB").
+     */
+    formatFileSize(bytes: number): string;
+    /**
+     * Converts the given file size in bytes into megabytes.
+     *
+     * @param bytes - The size of the file in bytes.
+     * @returns The size of the file in megabytes.
+     */
+    convertBytesToMB(bytes: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentsUploadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentsUploadService>;
+}
+
+declare class DocumentUploadComponent implements OnInit, OnDestroy {
+    /** Polling interval in milliseconds to update the indexing status of the uploaded documents */
+    pollingInterval: number;
+    flow: FlowDirective;
+    readonly flowConfig: flowjs.FlowOptions;
+    errorAlerts: string[];
+    dragging$: BehaviorSubject<boolean>;
+    indexing$: BehaviorSubject<boolean>;
+    indexingInfos$: BehaviorSubject<IndexingInfos | undefined>;
+    uploading$: BehaviorSubject<boolean>;
+    uploadingInfos$: BehaviorSubject<UploadingInfos | undefined>;
+    private _subscription;
+    documentsUploadService: DocumentsUploadService;
+    notificationsService: NotificationsService;
+    appService: AppService;
+    private readonly transloco;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Handles the submission of files.
+     *
+     * @remarks
+     * This method performs the following checks on the submitted files:
+     *
+     * 1. Checks if the number of files submitted exceeds the remainingFileCount defined in the constraints.
+     *    - If the number of files exceeds the allowed count, all files are removed from the flow.
+     *    - An error message is added to the error alerts.
+     *
+     * 2. Checks if the total size of the files submitted exceeds the remainingFileSize defined in the constraints.
+     *    - If the total size exceeds the allowed size, all files are removed from the flow.
+     *    - An error message is added to the error alerts.
+     *
+     * 3. Checks if the file extension of the files submitted is not allowed.
+     *    - If the file extension is not allowed, the file is removed from the flow.
+     *    - An error message is added to the error alerts.
+     */
+    private _onFilesSubmitted;
+    private _onFilesAdded;
+    onDragenter(): void;
+    onDragleave(event: DragEvent): void;
+    onDrop(): void;
+    trackTransfer(transfer: Transfer): string;
+    /**
+     * Initiates the upload process by invoking the `upload` method
+     * of the `flow` instance.
+     * The `upload` method is overridden in the `ngOnInit` method to match the requirements of the assistant API.
+     */
+    upload(): void;
+    /**
+     * Initiates the file upload process by preparing the form data,
+     * setting the uploading flag, and making an API call to upload the files.
+     *
+     * @remarks
+     * - Collects all files from the `flowJs` instance and appends them to a `FormData` object.
+     * - Subscribes to the upload process to handle progress updates, completion, and errors.
+     * - Triggers tracking the indexing process upon successful upload completion.
+     * - Cleans up the `flow` instance after the upload process is finalized.
+     */
+    private startUpload;
+    /**
+     * Tracks the indexing process for a single documents upload session by polling the API for its status.
+     *
+     * @param token - A unique token representing the single documents upload session.
+     *
+     * @remarks
+     * - Clears the uploading flags and sets the indexing flag to true before starting the process.
+     * - Polls the API every (pollingInterval: default = 1 second) to retrieve the current indexing status.
+     * - Updates the `indexingInfos` property with the latest status.
+     * - Stops polling when the indexing process is completed or an error occurs.
+     * - Cleans up by resetting the indexing flags and clearing the `indexingInfos` property when the process is finalized.
+     */
+    trackIndexingProcess(token: string): void;
+    /**
+     * Calculates the indexing progress as a percentage of completed documents.
+     *
+     * @param infos - The indexing information containing the list of documents and their statuses.
+     * @returns The progress as a number between 0 and 1, where 0 indicates no progress and 1 indicates all documents are processed (processed means either indexed or errored).
+     *          Returns 0 if the input is invalid or there are no documents.
+     */
+    getIndexingProgress(infos: IndexingInfos | undefined): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DocumentUploadComponent, "sq-document-upload", never, { "pollingInterval": { "alias": "pollingInterval"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DocumentListComponent implements OnInit, OnDestroy {
+    groupedUploadedDocuments$: BehaviorSubject<{
+        key: string;
+        value: UploadedDocument[];
+    }[]>;
+    documentToDelete?: UploadedDocument;
+    deletingAll: boolean;
+    private _subscription;
+    documentsUploadService: DocumentsUploadService;
+    notificationsService: NotificationsService;
+    appService: AppService;
+    private readonly transloco;
+    private readonly assistantUtils;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Updates the list of uploaded documents by fetching the latest data from the service.
+     * The fetched documents are grouped by date.
+     *
+     * @returns {void}
+     */
+    onUpdateUploadedDocumentsList(): void;
+    deleteDocument(event: Event, doc: UploadedDocument): void;
+    /**
+     * Handles the deletion of an uploaded document. This method triggers a confirmation modal
+     * to ensure the user wants to proceed with the deletion. If confirmed, it sends a request
+     * to delete the document and provides feedback to the user upon success or failure.
+     *
+     * @param event - The event object associated with the delete action, used to stop propagation.
+     * @param doc - The document to be deleted, represented as an instance of `UploadedDocument`.
+     *
+     * @remarks
+     * - Displays a confirmation modal with a warning message.
+     * - On confirmation, deletes the document.
+     * - Shows a success notification upon successful deletion.
+     * - Logs and notifies the user of any errors encountered during the deletion process.
+     */
+    performDeleteDocument(): void;
+    deleteAllDocuments(event?: Event): void;
+    /**
+     * Handles the deletion of all uploaded documents. This method triggers a confirmation modal
+     * to ensure the user wants to proceed with the deletion. If confirmed, it sends a request
+     * to delete the whole list of documents and provides feedback to the user upon success or failure.
+     *
+     * @param event - (Optional) The event object associated with the delete action, used to stop propagation.
+     *
+     * @remarks
+     * - Displays a confirmation modal with a warning message.
+     * - On confirmation, deletes all documents.
+     * - Shows a success notification upon successful deletion.
+     * - Logs and notifies the user of any errors encountered during the deletion process.
+     */
+    performDeleteAllDocuments(): void;
+    private _groupUploadedDocumentsByDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DocumentListComponent, "sq-document-list", never, {}, {}, never, never, true, never>;
+}
+
+declare class DocumentOverviewComponent implements OnInit, OnDestroy {
+    disabledUpload: boolean;
+    onUpload: EventEmitter<any>;
+    private _subscription;
+    documentsUploadService: DocumentsUploadService;
+    notificationsService: NotificationsService;
+    appService: AppService;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentOverviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DocumentOverviewComponent, "sq-document-overview", never, { "disabledUpload": { "alias": "disabledUpload"; "required": false; }; }, { "onUpload": "onUpload"; }, never, never, true, never>;
+}
+
+declare class ChatReferenceComponent {
+    readonly reference: i0.InputSignal<string>;
+    readonly attachment: i0.InputSignal<ChatContextAttachment>;
+    readonly partId: i0.InputSignal<number | undefined>;
+    readonly referenceMap: i0.InputSignal<Map<string, ChatContextAttachment> | undefined>;
+    readonly images: i0.InputSignal<string[]>;
+    readonly pages: i0.InputSignal<string[]>;
+    readonly openDocument: i0.OutputEmitterRef<ChatContextAttachment>;
+    readonly openPreview: i0.OutputEmitterRef<ChatContextAttachment>;
+    readonly modalTpl: i0.Signal<ElementRef<HTMLDialogElement> | undefined>;
+    readonly modalRef: i0.WritableSignal<any>;
+    readonly groupedImagesIds: i0.Signal<Record<string, number[]>>;
+    readonly groupedPagesIds: i0.Signal<Record<string, number[]>>;
+    get parts(): DocumentPart[];
+    findImage: (arr: any[], number: number) => any | undefined;
+    findPage: (arr: any[], number: number) => any | undefined;
+    expandAttachment(): void;
+    modalClicked(ref: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatReferenceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChatReferenceComponent, "sq-chat-reference", never, { "reference": { "alias": "reference"; "required": true; "isSignal": true; }; "attachment": { "alias": "attachment"; "required": true; "isSignal": true; }; "partId": { "alias": "partId"; "required": false; "isSignal": true; }; "referenceMap": { "alias": "referenceMap"; "required": false; "isSignal": true; }; "images": { "alias": "images"; "required": false; "isSignal": true; }; "pages": { "alias": "pages"; "required": false; "isSignal": true; }; }, { "openDocument": "openDocument"; "openPreview": "openPreview"; }, never, never, true, never>;
+}
+
+declare class ChatReferenceImageComponent {
+    readonly id: i0.InputSignal<string>;
+    readonly ref: i0.InputSignal<MessageImageReference>;
+    readonly openPreview: i0.OutputEmitterRef<Omit<RawAttachment, "type"> & {
+        $partId: number;
+        parts: DocumentPart[];
+    }>;
+    readonly openDocument: i0.OutputEmitterRef<Omit<RawAttachment, "type">>;
+    readonly openModal: i0.OutputEmitterRef<void>;
+    readonly modalTpl: i0.Signal<ElementRef<HTMLDialogElement> | undefined>;
+    previewClicked(): void;
+    documentClicked(): void;
+    modalClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatReferenceImageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChatReferenceImageComponent, "ChatReferenceImage", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "ref": { "alias": "ref"; "required": true; "isSignal": true; }; }, { "openPreview": "openPreview"; "openDocument": "openDocument"; "openModal": "openModal"; }, never, never, true, never>;
+}
+
+declare class ChatReferencePageComponent {
+    readonly id: i0.InputSignal<string>;
+    readonly ref: i0.InputSignal<MessageImageReference>;
+    readonly openPreview: i0.OutputEmitterRef<Omit<RawAttachment, "type"> & {
+        $partId: number;
+        parts: DocumentPart[];
+    }>;
+    readonly openDocument: i0.OutputEmitterRef<Omit<RawAttachment, "type">>;
+    readonly openModal: i0.OutputEmitterRef<void>;
+    readonly modalTpl: i0.Signal<ElementRef<HTMLDialogElement> | undefined>;
+    previewClicked(): void;
+    documentClicked(): void;
+    modalClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatReferencePageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChatReferencePageComponent, "ChatReferencePage", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "ref": { "alias": "ref"; "required": true; "isSignal": true; }; }, { "openPreview": "openPreview"; "openDocument": "openDocument"; "openModal": "openModal"; }, never, never, true, never>;
+}
+
+/**
+ * Service to register custom elements in the Angular application.
+ * This service is used to define custom elements that can be used in the application.
+ * It is called through APP_INITIALIZER to ensure that custom elements are registered before the application starts.
+ */
+declare class CustomElementsService {
+    private _injector;
+    private readonly _customElements;
+    setupCustomElements(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomElementsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomElementsService>;
+}
+declare function initializeCustomElements(customElementsService: CustomElementsService): () => void;
+
+declare const ASSISTANT_CUSTOM_ELEMENTS: InjectionToken<Record<string, Type<unknown>>>;
+
+declare class DocumentReferenceComponent implements OnChanges {
+    id: any;
+    attachment: any;
+    ref: ChatContextAttachment;
+    ngOnChanges(): void;
+    onOpenPreview(attachment: ChatContextAttachment): void;
+    onOpenDocument(attachment: ChatContextAttachment): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentReferenceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DocumentReferenceComponent, "document-reference", never, { "id": { "alias": "id"; "required": false; }; "attachment": { "alias": "attachment"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PageReferenceComponent implements OnChanges {
+    id: any;
+    attachment: any;
+    ref: MessageImageReference;
+    ngOnChanges(): void;
+    onOpenPreview(attachment: ChatContextAttachment): void;
+    onOpenDocument(attachment: ChatContextAttachment): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageReferenceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageReferenceComponent, "page-reference", never, { "id": { "alias": "id"; "required": false; }; "attachment": { "alias": "attachment"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ImageReferenceComponent implements OnChanges {
+    id: any;
+    attachment: any;
+    ref: MessageImageReference;
+    ngOnChanges(): void;
+    onOpenPreview(attachment: ChatContextAttachment): void;
+    onOpenDocument(attachment: ChatContextAttachment): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageReferenceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageReferenceComponent, "image-reference", never, { "id": { "alias": "id"; "required": false; }; "attachment": { "alias": "attachment"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CodeBlockComponent {
+    langname: string;
+    el: ElementRef<any>;
+    copying: i0.WritableSignal<boolean>;
+    handleClick(event: Event): void;
+    copyCodeToClipboard(code: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CodeBlockComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CodeBlockComponent, "code-block", never, { "langname": { "alias": "langname"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TableToolsComponent {
+    private readonly host;
+    copied: i0.WritableSignal<boolean>;
+    get table(): HTMLTableElement | null;
+    copyAsCSV(): void;
+    downloadAsCSV(): void;
+    private extractCSV;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableToolsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableToolsComponent, "table-tools", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ChartPlotComponent implements AfterViewInit {
+    chartPlotRef: ElementRef<HTMLCanvasElement>;
+    private destroyRef;
+    private chart?;
+    constructor();
+    ngAfterViewInit(): void;
+    private parseChartJsConfig;
+    private getChartJsConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartPlotComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartPlotComponent, "chart-plot", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare function markdownItCodeBlockPlugin(md: MarkdownIt): void;
+
+/**
+ * A markdown-it plugin to convert [Img-x.y.z], where x, y and z are numbers, into a <image-reference id="x.y.z">Img-x.y.z</image-reference> HTML tag.
+ *
+ * For example, when attachment x is found in the referencesMap and which contains the image z of the part y, [Img-x.y.z] will be converted to <image-reference id="x.y.z">Img-x.y.z</image-reference>.
+ * If the attachment x, the part y or the image z is not found, it will remain as plain text [Img-x.y.z] in a span tag : <span>[Img-x.y.z]</span>
+ */
+declare const EMBEDDED_IMAGE_NAME = "embedded-image-reference";
+declare function markdownItImageReferencePlugin(md: MarkdownIt): void;
+
+/**
+ * This plugin overrides the default link renderer to add `target="_blank"` and `rel="noopener noreferrer"` to all links.
+ */
+declare function markdownItLinkPlugin(md: MarkdownIt): void;
+
+/**
+ * A markdown-it plugin to convert [Page-x.n], where x and n are numbers, into a <page-reference id="x.n">Page-x.n</page-reference> HTML tag.
+ *
+ * For example, when attachment x is found in the referencesMap and which contains the page n, [Page-x.n] will be converted to <page-reference id="x.n">Page-x.n</page-reference>.
+ * If the attachment x or the page n is not found, it will remain as plain text [Page-x.n] in a span tag : <span>[Page-x.n]</span>
+ */
+declare const EMBEDDED_PAGE_NAME = "embedded-page-reference";
+declare function markdownItPageReferencePlugin(md: MarkdownIt): void;
+
+/**
+ * A markdown-it plugin to convert [n] where n is a number into a <document-reference id="n">n</document-reference> HTML tag.
+ *
+ * For example, when attachment 123 is found in the referencesMap, [123] will be converted to <document-reference id="123">123</document-reference>.
+ * If the attachment is not found, it will remain as plain text [123] in a span tag : <span>[123]</span>
+ */
+declare function markdownItDocumentReferencePlugin(md: MarkdownIt): void;
+
+declare function markdownItTableToolsPlugin(md: MarkdownIt): void;
+
+/**
+ * Markdown-it plugin to replace ```chartjs fenced blocks
+ * with <chart-plot> custom elements.
+ */
+declare function markdownItChartJsPlugin(md: MarkdownIt): void;
+
+type MarkdownItPlugin = (md: MarkdownIt, ...params: any[]) => void;
+declare const ASSISTANT_MARKDOWN_IT_PLUGINS: InjectionToken<MarkdownItPlugin[]>;
+
+/**
+ * Initializes a global fetch interceptor that patches the native window.fetch function.
+ *
+ * This function replaces the browser's native fetch with a custom implementation that:
+ * - Preserves all original fetch functionality and behavior
+ * - Intercepts HTTP responses that are not successful (!response.ok)
+ * - Automatically handles errors through the GlobalErrorHandlerService when available
+ * - Logs network errors to the console for debugging purposes
+ *
+ * The interceptor uses Angular's dependency injection system to retrieve the
+ * GlobalErrorHandlerService and delegate error handling to it. If the injector
+ * is not available, the function gracefully continues without error handling.
+ *
+ * @remarks
+ * - This function should be called once during application initialization
+ * - The original fetch function is preserved and all requests are forwarded to it
+ * - Non-ok responses are still returned to the caller after error handling
+ * - Network errors (connection failures, etc.) are logged and re-thrown
+ *
+ * @example
+ * ```typescript
+ * // Call during app initialization
+ * initializeFetchInterceptor();
+ *
+ * // All subsequent fetch calls will be automatically intercepted
+ * fetch('/api/data').then(response => {
+ *   // Error handling already occurred if response was not ok
+ * });
+ * ```
+ */
+declare function initializeFetchInterceptor(): void;
+
+/**
+ * Function to set the global Injector reference.
+ */
+declare function setAppInjector(injector: Injector): void;
+/**
+ * Function to retrieve the global Injector reference.
+ */
+declare function getAppInjector(): Injector;
+
+/**
+ * Injection Token for the specific function to execute on a 401 Unauthorized error.
+ */
+declare const ASSISTANT_UNAUTHORIZED_ACTION_TOKEN: InjectionToken<() => void>;
+declare class GlobalErrorHandlerService {
+    private unauthorizedAction;
+    /** Prevents infinite unauthorized attempts */
+    private _authAttempted;
+    /** Tracks if a re-authentication process is currently in progress */
+    private _reauthInProgress;
+    private authEventListener;
+    constructor();
+    /**
+     * Sets up a global listener for the `authenticated` event.
+     * When re-authentication succeeds (authenticated === true),
+     * reset the auth lock so another 401 can trigger again later.
+     */
+    private setupAuthEventListener;
+    /**
+     * Main entry point to handle fetch or HTTP errors globally.
+     */
+    handleFetchError(url: string, status: number, statusText: string): void;
+    /**
+     * Handles 401 errors by triggering re-authentication only once
+     * until authentication is restored (via the DOM event).
+     */
+    private handleUnauthorized;
+    /**
+     * Clean up global event listener when Angular destroys this service.
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalErrorHandlerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalErrorHandlerService>;
+}
+
+/**
+ * Handles unauthorized HTTP responses (401) by clearing session data and reloading the page.
+ *
+ * This function is triggered when a 401 Unauthorized response is detected during API calls.
+ * It performs cleanup operations by removing stored credentials from session storage
+ * and forces a page reload to redirect the user to the login flow.
+ *
+ * @remarks
+ * This function directly manipulates the browser's session storage and window location,
+ * making it suitable for client-side applications only.
+ *
+ */
+declare const handleUnauthorizedLogic: () => void;
+
+export { ASSISTANT_CUSTOM_ELEMENTS, ASSISTANT_MARKDOWN_IT_PLUGINS, ASSISTANT_UNAUTHORIZED_ACTION_TOKEN, ChartPlotComponent, ChatComponent, ChatReferenceComponent, ChatReferenceImageComponent, ChatReferencePageComponent, ChatService, ChatSettingsV3Component, CodeBlockComponent, CustomElementsService, DocumentListComponent, DocumentOverviewComponent, DocumentReferenceComponent, DocumentUploadComponent, DocumentsUploadService, EMBEDDED_IMAGE_NAME, EMBEDDED_PAGE_NAME, FormatIconComponent, GlobalErrorHandlerService, ImageReferenceComponent, InitialsAvatarComponent, InstanceManagerService, NotificationsService, PageReferenceComponent, SavedChatsComponent, TableToolsComponent, chatConfigSchema, connectionSettingsSchema, getAppInjector, handleUnauthorizedLogic, initializeCustomElements, initializeFetchInterceptor, markdownItChartJsPlugin, markdownItCodeBlockPlugin, markdownItDocumentReferencePlugin, markdownItImageReferencePlugin, markdownItLinkPlugin, markdownItPageReferencePlugin, markdownItTableToolsPlugin, setAppInjector };
+export type { ActionMessage, ActionResultEvent, ActionStartEvent, ActionStopEvent, AdditionalServiceSettings, ChatConfig, ChatContextAttachment, ChatMessage, ChatPayload, ChatProgress, ChatResponse, ChatUsageMetrics, ConnectionSettings, ContextMessageEvent, DebugMessage, DebugMessageEvent, DefaultValues, DeleteSavedChatResponse, DocumentPage, DocumentPart, ErrorEvent, GllmFunction, GllmFunctionParameter, GllmModelDescription, HistoryEvent, HttpChatResponse, IndexingInfos, InitChat, KvObject, ListObject, MarkdownItPlugin, MessageEvent, MessageHandler, ModeSettings, NotificationType, PluginVersion, Quota, QuotaEvent, RawAttachment, RawMessage, RawResponse, SavedChat, SavedChatHistory, SavedChatResponse, SavedChatSettings, ServiceSettings, SuggestedAction, SuggestedActionsEvent, TextChunksOptions, TokenConsumption, UiSettings, UploadConfig, UploadEvent, UploadProgressEvent, UploadResponse, UploadResponseEvent, UploadedDocument, UploadedDocuments, UploadingInfos, UserTokenConsumption, additionalWorkflowProperties, deleteDocumentsResponse };