@adzen/doohbot 1.0.1 → 1.0.2

package/index.d.ts

@@ -0,0 +1,1301 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, RendererFactory2, ElementRef, Renderer2, Signal, OnInit, SimpleChanges, InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { OverlayContainer } from '@angular/cdk/overlay';
+import { SafeHtml } from '@angular/platform-browser';
+import { MatDialog } from '@angular/material/dialog';
+import { MatSnackBar } from '@angular/material/snack-bar';
+
+interface LoginRequest {
+    username: string;
+    password: string;
+    rememberMe?: boolean;
+}
+
+/**
+ * Configuration for Doohbot API integration.
+ *
+ * Defines how Doohbot communicates with a backend API,
+ * either the default Doohbot service or a custom/self-hosted implementation.
+ */
+interface DoohbotApiConfig {
+    /**
+     * Base URL of the backend API.
+     *
+     * Must be a publicly accessible HTTP(S) endpoint.
+     *
+     * @example 'https://api.doohbot.com/'
+     */
+    baseUrl: string;
+    /**
+     * Optional API key used for authenticating API requests.
+     *
+     * If omitted, authentication is expected to be handled
+     * via federated login or other mechanisms.
+     */
+    apiKey?: string;
+    /**
+     * Additional HTTP headers to include with every API request.
+     *
+     * Useful for custom authentication schemes, tracing headers,
+     * or gateway integrations.
+     *
+     * @example { 'X-Tenant-Id': 'acme' }
+     */
+    customHeaders?: Record<string, string>;
+    /**
+     * Enables automatic retry for transient API failures.
+     *
+     * Retries are typically applied to network errors or
+     * idempotent requests only.
+     *
+     * @default true
+     */
+    enableRetry?: boolean;
+    /**
+     * Maximum number of retry attempts when retries are enabled.
+     *
+     * @default 2
+     */
+    retryAttempts?: number;
+    /**
+     * Delay between retry attempts, in milliseconds.
+     *
+     * @default 1000
+     */
+    retryDelay?: number;
+}
+
+/**
+ * Theme and visual customization options for Doohbot.
+ * All properties are optional and can be partially overridden.
+ */
+interface DoohbotThemeConfig {
+    /**
+     * Enables dragging of the chatbot window.
+     * @default false
+     */
+    enableDrag?: boolean;
+    /**
+     * Enables resizing of the chatbot window.
+     * @default false
+     */
+    enableResize?: boolean;
+    /**
+     * Defines the chatbot button layout style.
+     * - `fab`: Floating action button
+     * - `sidebar`: Fixed sidebar
+     * - `sidebar-top`: Sidebar anchored to top
+     * - `sidebar-bottom`: Sidebar anchored to bottom
+     * @default 'fab'
+     */
+    buttonStyle?: 'fab' | 'sidebar' | 'sidebar-top' | 'sidebar-bottom';
+    /**
+     * Font family applied to all chatbot text.
+     * Accepts any valid CSS font-family value.
+     * @example 'Inter, Roboto, sans-serif'
+     */
+    fontFamily?: string;
+    /**
+     * Predefined color palette for the chatbot.
+     * If provided, it overrides individual color settings with palette defaults.
+     * @example 'aqua'
+     */
+    palette?: 'doohbot' | 'aqua' | 'candy' | 'forest' | 'midnight' | 'sunset' | 'slate';
+    /**
+     * Primary brand color used for accents and highlights.
+     * @example '#4f46e5'
+     */
+    primaryColor?: string;
+    /**
+     * Secondary brand color used for secondary accents.
+     * @example '#6366f1'
+     */
+    secondaryColor?: string;
+    /**
+     * Background color of the chatbot window.
+     * @example '#ffffff'
+     */
+    backgroundColor?: string;
+    /**
+     * Background color of the chat input field.
+     * @example '#f9fafb'
+     */
+    chatInputColor?: string;
+    /**
+     * Primary text color.
+     * @example '#111827'
+     */
+    textColor?: string;
+    /**
+     * Alternative text color for muted or secondary text.
+     * @example '#6b7280'
+     */
+    textAltColor?: string;
+    /**
+     * Secondary text color for less prominent text.
+     * @example '#9ca3af'
+     */
+    secondaryTextColor?: string;
+    /**
+     * Hint or placeholder text color.
+     * @example '#9ca3af'
+     */
+    hintTextColor?: string;
+    /**
+     * Background color for buttons.
+     * @example '#4f46e5'
+     */
+    buttonColor?: string;
+    /**
+     * Background color for user messages.
+     * @example '#e0e7ff'
+     */
+    userMessageColor?: string;
+    /**
+     * Background color for bot messages.
+     * @example '#f3f4f6'
+     */
+    botMessageColor?: string;
+    /**
+     * Text color for user messages.
+     * @example '#1f2937'
+     */
+    userTextColor?: string;
+    /**
+     * Text color for bot messages.
+     * @example '#111827'
+     */
+    botTextColor?: string;
+    /**
+     * Border color used across chatbot UI elements.
+     * @example '#e5e7eb'
+     */
+    borderColor?: string;
+    /**
+     * Border shadow color for elevated elements.
+     * @example 'rgba(0, 0, 0, 0.1)'
+     */
+    borderShadowColor?: string;
+    /**
+     * Top border accent color.
+     * @example '#4f46e5'
+     */
+    borderTopColor?: string;
+    /**
+     * Color of the typing indicator animation.
+     * @example '#6b7280'
+     */
+    typingIndicatorColor?: string;
+    /**
+     * Utility white color reference.
+     * @example '#ffffff'
+     */
+    white?: string;
+    /**
+     * Utility black color reference.
+     * @example '#000000'
+     */
+    black?: string;
+    /**
+     * Utility grey color reference.
+     * @example '#9ca3af'
+     */
+    grey?: string;
+    /**
+     * Utility red color reference.
+     * @example '#ef4444'
+     */
+    red?: string;
+    /**
+     * Utility yellow color reference.
+     * @example '#facc15'
+     */
+    yellow?: string;
+    /**
+     * Utility orange color reference.
+     * @example '#f97316'
+     */
+    orange?: string;
+    /**
+     * Utility green color reference.
+     * @example '#22c55e'
+     */
+    green?: string;
+    /**
+     * Utility blue color reference.
+     * @example '#3b82f6'
+     */
+    blue?: string;
+}
+
+/**
+ * Root configuration contract for the Doohbot library.
+ *
+ * This interface defines all runtime, integration, and customization
+ * options required to initialize and operate Doohbot inside a host application.
+ *
+ * Designed to be provided via dependency injection (e.g. `provideDoohbot()`).
+ */
+interface DoohbotConfig {
+    /**
+     * Runtime environment in which Doohbot is running.
+     * Used for environment-specific behavior such as logging,
+     * feature flags, and API behavior.
+     *
+     * @example 'production'
+     */
+    environment: 'development' | 'test' | 'stage' | 'production';
+    /**
+     * Public URL path to the license file.
+     *
+     * The license file must be accessible via HTTP (e.g. served from `/assets`).
+     * File system paths are not supported.
+     *
+     * @example 'assets/doohbot_license.json'
+     */
+    licenseFilePath?: string;
+    /**
+     * Secret used for encrypting persisted client-side data.
+     * If not provided, default will be used.
+     */
+    storageSecret?: string;
+    /**
+     * Chats use the `streaming` by default.
+     * Pass `true` to use normal http calls for chat.
+     */
+    useNonStreamingChat?: boolean;
+    /**
+     * Optional API configuration.
+     * Use this to override the default Doohbot backend
+     * or integrate with a custom/self-hosted API.
+     */
+    api?: DoohbotApiConfig;
+    /**
+     * Optional theme and visual customization options.
+     *
+     * Provides full control over the chatbot’s appearance, including:
+     * - Button layout and style
+     * - Colors (primary, secondary, backgrounds, borders, messages)
+     * - Fonts
+     * - Dragging/resizing behavior
+     *
+     * Only the fields you specify will override defaults; any omitted
+     * fields will use the library’s default values.
+     *
+     * @example
+     * ```ts
+     * theme: {
+     *   buttonStyle: 'fab',
+     *   primaryColor: '#4f46e5',
+     *   backgroundColor: '#ffffff',
+     *   textColor: '#111827',
+     *   userMessageColor: '#e0e7ff',
+     *   botMessageColor: '#f3f4f6',
+     *   fontFamily: 'Inter, Roboto, sans-serif',
+     *   enableDrag: true,
+     *   enableResize: true
+     * }
+     * ```
+     */
+    theme?: DoohbotThemeConfig;
+}
+
+/**
+ * Centralized service for managing Doohbot configuration.
+ * Provides reactive access and runtime updates.
+ * Singleton via providedIn: 'root'.
+ */
+declare class DoohbotConfigService implements OnDestroy {
+    private configSignal;
+    private readonly configSubject;
+    readonly config$: Observable<DoohbotConfig>;
+    /**
+     * Current runtime environment for Doohbot.
+     *
+     * Drives environment-specific behavior such as:
+     * - API behavior
+     * - logging verbosity
+     * - feature toggles
+     * - safety defaults
+     *
+     * This value is mandatory and always resolved during bootstrap.
+     */
+    readonly environment: () => DoohbotConfig["environment"];
+    /**
+     * Path to the public license file.
+     * Returns an empty string if not configured.
+     */
+    readonly licenseFilePath: () => string;
+    /**
+     * Secret used for encrypting persisted client-side data.
+     * If not provided, default will be used.
+     */
+    readonly storageSecret: () => string;
+    /**
+     * Chats use the `streaming` by default.
+     * Pass `true` to use normal http calls for chat.
+     */
+    readonly useNonStreamingChat: () => boolean;
+    /**
+     * Full API configuration object.
+     * Undefined if API integration is not configured.
+     */
+    readonly api: () => DoohbotApiConfig | undefined;
+    /**
+     * Theme customization configuration.
+     * Undefined if no theme overrides are provided.
+     */
+    readonly theme: () => DoohbotThemeConfig | undefined;
+    constructor(injectedConfig?: Partial<DoohbotConfig>);
+    /**
+     * Update configuration at runtime.
+     * @param value Partial config updates
+     */
+    update(value: Partial<DoohbotConfig>): void;
+    private validateConfig;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DoohbotConfigService, [{ optional: true; }]>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DoohbotConfigService>;
+}
+
+interface AuthResult {
+    access_token: string;
+    refresh_token: string;
+}
+
+interface FederatedLoginRequest {
+    access_token: string;
+    remember_me?: boolean;
+}
+
+declare class StorageService {
+    private readonly storageKey;
+    private readonly secretKey;
+    private readonly storage;
+    constructor(config: DoohbotConfig);
+    /**
+     * Store a value under the given key.
+     */
+    set<T>(key: string, value: T): void;
+    /**
+     * Retrieve a stored value by key.
+     */
+    get<T>(key: string): T | null;
+    /**
+     * Remove a specific key from storage.
+     */
+    remove(key: string): void;
+    /**
+     * Clear all Doohbot-related storage.
+     */
+    clear(): void;
+    /**
+     * Validate storage integrity without mutating it.
+     */
+    isValid(): boolean;
+    private readAll;
+    private encrypt;
+    private decrypt;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StorageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StorageService>;
+}
+
+declare class HttpService {
+    private http;
+    private configService;
+    constructor(http: HttpClient, configService: DoohbotConfigService);
+    get apiUrl(): string;
+    get(url: string, param?: object, nestedParam?: boolean, showLoader?: boolean, refresh?: boolean, headers?: HttpHeaders): Promise<any>;
+    private buildHttpParams;
+    post(url: string, param?: object, showLoader?: boolean, headers?: HttpHeaders): Promise<any>;
+    patch(url: string, param?: object, showLoader?: boolean, headers?: HttpHeaders): Promise<any>;
+    put(url: string, param?: object, showLoader?: boolean, headers?: HttpHeaders): Promise<any>;
+    delete(url: string, param?: object, showLoader?: boolean, headers?: HttpHeaders): Promise<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HttpService>;
+}
+
+declare class AuthService {
+    private http;
+    private storageService;
+    private configService;
+    private jwtHelper;
+    private isRefreshing;
+    private refreshTokenSubject;
+    private readonly isAuthenticatedSubject;
+    private readonly federatedAuthTokenSubject;
+    private readonly rememberMeSubject;
+    private readonly licenseFileSubject;
+    private readonly licenseCodeSubject;
+    readonly isAuthenticated$: Observable<boolean>;
+    private apiBaseUrl;
+    /**
+     * True if request is an auth endpoint
+     */
+    isAuthUrl(url: string): boolean;
+    /**
+     * True if request goes to our backend API
+     */
+    isInternalApiRequest(url: string): boolean;
+    /**
+     * Sets current license file
+     */
+    readonly setLicenseFile: (data: Map<string, string> | null) => void;
+    /**
+     * Gets current license file
+     */
+    readonly licenseFile: () => Map<string, string> | null;
+    /**
+     * Sets current federated auth token
+     */
+    readonly setFederatedAuthToken: (token: string | null) => void;
+    /**
+     * Gets current federated auth token
+     */
+    readonly federatedAuthToken: () => string | null;
+    /**
+     * Sets current license code
+     */
+    readonly setLicenseCode: (code: string | null) => void;
+    /**
+     * Gets current license code
+     */
+    readonly licenseCode: () => string | null;
+    /**
+     * Sets rememberMe
+     */
+    readonly setRememberMe: (value: boolean | false) => void;
+    /**
+     * Gets rememberMe
+     */
+    readonly rememberMe: () => boolean | false;
+    /**
+     * Gets current license key for active license code
+     */
+    readonly currentLicenseKey: () => string | null;
+    /**
+     * Resolved API base URL
+     */
+    readonly apiUrl: () => string;
+    /**
+     * Logged-in user display name
+     */
+    readonly loggedInUserName: () => string;
+    /**
+     * Logged-in user avatar URL
+     */
+    readonly loggedInUserImageUrl: () => string | null;
+    /**
+     * Logged-in user role
+     */
+    readonly loggedInUserRole: () => string;
+    /**`user_id` of logged in user */
+    readonly getUserId: () => string | null;
+    /**`username` of logged in user */
+    readonly getUsername: () => string | null;
+    /**`rememberMe` of logged in user */
+    readonly getRememberMe: () => string | null;
+    /**`roles` of logged in user */
+    readonly getRoles: () => string | null;
+    /**`permissions` of logged in user */
+    readonly getPermissions: () => string | null;
+    /**`organization_id` of logged in user */
+    readonly getOrganizationId: () => string | null;
+    /**`company_id` of logged in user */
+    readonly getCompanyId: () => string | null;
+    /**`office_id` of logged in user */
+    readonly getOfficeId: () => string | null;
+    /**`access_token` of logged in user */
+    readonly getAccessToken: () => string | null;
+    /**`refresh_token` of logged in user */
+    readonly getRefreshToken: () => string | null;
+    /**
+     * Gets if user is authenticated
+     */
+    readonly getIsAuthenticated: () => boolean;
+    isLoggingIn: _angular_core.WritableSignal<boolean>;
+    authError: _angular_core.WritableSignal<string | null>;
+    authSuccess: _angular_core.WritableSignal<string | null>;
+    constructor(http: HttpService, storageService: StorageService, configService: DoohbotConfigService);
+    /**
+     * Initializes the federated authentication flow.
+     *
+     * Validates all required prerequisites (configuration, license, tokens)
+     * and triggers authentication only when the system is in a valid state.
+     *
+     * This method is idempotent and safe to call multiple times; authentication
+     * will execute only once when all conditions are satisfied.
+     */
+    initFederatedAuthFlow(): void;
+    /**
+     * Restores authenticated state with all prerequisites satisfied.
+     * Handles authentication state for normal manual login.
+     */
+    initNormalLoginAuthState(): void;
+    /**
+     * Authenticate user based on stored tokens or refresh tokens.
+     */
+    private authenticate;
+    /**
+     * Authenticate user with federated credentials
+     */
+    federatedLogin(param: FederatedLoginRequest): Promise<boolean>;
+    /**
+     * Authenticate user with credentials
+     */
+    login(param: LoginRequest): Promise<boolean>;
+    /**
+     * Refresh login token. Concurrent calls wait for the first refresh to complete.
+     */
+    refreshLogin(): Observable<AuthResult | null>;
+    /**
+     * Logout logic enhanced with UI signals
+     */
+    logout(refreshToken?: string): Promise<boolean>;
+    private federateLoginHttpHelper;
+    private loginHttpHelper;
+    private refreshLoginHttpHelper;
+    private logoutHttpHelper;
+    private buildLicenseHeader;
+    setSession(session: AuthResult, rememberMe?: boolean): void;
+    private isTokenExpired;
+    /**
+     * Clear all authentication related data from local storage, session storage, cache, and tokens.
+     * This method is called when the user logs out.
+     */
+    clear(): void;
+    clearTabInfo(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AuthService>;
+}
+
+interface ApiResponse<T> {
+    success: boolean;
+    message: string;
+    data?: T;
+}
+
+interface CustomInstructions {
+    instructions?: string;
+    preferences?: string;
+    user_context_id?: string;
+}
+interface AppearanceSettings {
+    theme: 'light' | 'dark' | 'auto';
+    language: string;
+}
+interface PersonalizationSettings {
+    customInstructions: CustomInstructions;
+    appearance: AppearanceSettings;
+    meta: {
+        version: number;
+        lastUpdated: number;
+    };
+}
+declare class PersonalizationService {
+    private http;
+    private storage;
+    private authService;
+    private _settings;
+    settings: _angular_core.Signal<PersonalizationSettings>;
+    constructor(http: HttpService);
+    private getStorageKey;
+    /**
+     * Update custom instructions
+     */
+    updateInstructions(instructions: Partial<CustomInstructions>): void;
+    /**
+     * Update appearance settings
+     */
+    updateAppearance(appearance: Partial<AppearanceSettings>): void;
+    /**
+     * Reset all personalization to defaults
+     */
+    resetToDefaults(): void;
+    saveCustomInstructions(data: CustomInstructions): Promise<void>;
+    loadCustomInstructions(): void;
+    getCustomInstructionHttpHelper(showLoader?: boolean): Promise<ApiResponse<CustomInstructions>>;
+    private loadSettings;
+    private saveSettings;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PersonalizationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PersonalizationService>;
+}
+
+type ThemeMode = 'light' | 'dark' | 'auto';
+declare class ThemeService implements OnDestroy {
+    private overlay;
+    private personalization;
+    private configService;
+    private renderer;
+    private _theme;
+    theme: _angular_core.Signal<ThemeMode>;
+    private _activeTheme;
+    activeTheme: _angular_core.Signal<"light-theme" | "dark-theme">;
+    private observer;
+    constructor(rendererFactory: RendererFactory2, overlay: OverlayContainer, personalization: PersonalizationService, configService: DoohbotConfigService);
+    private _currentConfig;
+    private rootElement;
+    setThemeConfig(config: DoohbotThemeConfig, rootElement: HTMLElement): void;
+    applyPrimaryColorToGlobal(colorInput: string): void;
+    /**
+     * Helper to convert hex to comma-separated RGB
+     */
+    private hexToRgb;
+    /**
+     * Simple luminance-based contrast calculation
+     * Returns #ffffff for dark colors and #000000 for light colors
+     */
+    private getContrastColor;
+    setTheme(mode: ThemeMode): void;
+    private updateActiveTheme;
+    private handleAutoTheme;
+    private detectAndApplyParentTheme;
+    private isParentDark;
+    private applyThemeToGlobal;
+    private applyPaletteToGlobal;
+    private cleanupObservers;
+    ngOnDestroy(): void;
+    /**
+     * @deprecated Manual CSS variable application is now handled via theme.css tokens
+     */
+    applyCssVariables(element: HTMLElement, config: DoohbotThemeConfig | undefined): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+declare class FullscreenDirective {
+    private el;
+    private renderer;
+    private isFullScreen;
+    private preFullscreenState;
+    fullscreenTarget: string;
+    constructor(el: ElementRef, renderer: Renderer2);
+    toggle(): void;
+    getFullscreenState(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FullscreenDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FullscreenDirective, "[appFullscreen]", never, { "fullscreenTarget": { "alias": "fullscreenTarget"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Message role types for chat messages
+ */
+type MessageRole = 'user' | 'model';
+
+interface Message {
+    id: string;
+    sender: MessageRole;
+    senderName?: string;
+    text: string;
+    textHtml?: SafeHtml;
+    chunks?: string[];
+    timestamp?: Date;
+    showSuggestions?: boolean;
+    platformTenant?: string;
+    subTenant?: string;
+    agent?: string;
+    completed: boolean;
+    isHistory: boolean;
+    copied?: boolean;
+}
+
+interface ChatSessionDto {
+    response_id: string;
+    last_message_at: Date;
+    title: string;
+    messages: Message[];
+    userId: string;
+}
+
+/**
+ * Chat Message from API
+ */
+interface ChatMessage {
+    message_id?: string;
+    role: MessageRole;
+    content: string;
+    model_name: string | null;
+    prompt_tokens: number | null;
+    completion_tokens: number | null;
+    created_at: string;
+}
+/**
+ * Chat Session from API
+ */
+interface ChatSessionResponse {
+    response_id: string;
+    title: string;
+    last_message_at: string;
+    chat_session_id?: string;
+    is_active?: boolean;
+    created_at?: string;
+    updated_at?: string;
+    messages?: ChatMessage[];
+}
+
+declare class ChatHistoryService {
+    private chatApiService;
+    sessions: _angular_core.WritableSignal<ChatSessionDto[]>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    isLoadingMore: _angular_core.WritableSignal<boolean>;
+    hasMore: _angular_core.WritableSignal<boolean>;
+    historyOffset: _angular_core.WritableSignal<number>;
+    isCacheValid: _angular_core.WritableSignal<boolean>;
+    processingSessionId: _angular_core.WritableSignal<string | null>;
+    /**
+     * Map API session response to ChatSession model
+     */
+    mapSessionResponseToSession(sessionResponse: ChatSessionResponse, userId: string): ChatSessionDto;
+    /**
+     * Load all chat sessions for a specific user
+     */
+    loadSessions(userId: string, forceRefresh?: boolean): Promise<void>;
+    /**
+     * Load more sessions for infinite scroll
+     */
+    loadMoreSessions(userId: string): Promise<void>;
+    /**
+     * Load messages for a specific session
+     */
+    loadSessionMessages(sessionId: string): Promise<Message[]>;
+    /**
+     * Delete a specific session
+     */
+    deleteSession(sessionId: string, userId: string): Promise<void>;
+    /**
+     * Delete all history
+     */
+    deleteAllHistory(userId: string): Promise<void>;
+    /**
+     * Update session title
+     */
+    updateSessionTitle(sessionId: string, newTitle: string, userId: string): Promise<boolean>;
+    /**
+     * Invalidate cache
+     */
+    invalidateCache(): void;
+    /**
+     * Clear all history state
+     */
+    clearState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatHistoryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChatHistoryService>;
+}
+
+/**
+ * ChatUIStateService - Centralized UI state management
+ *
+ * Manages all UI-related state for the chat component including:
+ * - Chat window open/close state
+ * - History sidebar visibility
+ * - Unread message tracking
+ * - Fullscreen state
+ *
+ * This service uses Angular signals for reactive state management,
+ * allowing components to subscribe to state changes efficiently.
+ */
+declare class ChatUIStateService {
+    /**
+     * Whether the chat window is currently open
+     */
+    isChatOpen: _angular_core.WritableSignal<boolean>;
+    /**
+     * Whether the history sidebar is currently open
+     */
+    isHistorySidebarOpen: _angular_core.WritableSignal<boolean>;
+    /**
+     * Whether the chat is in fullscreen mode
+     */
+    isFullScreen: _angular_core.WritableSignal<boolean>;
+    /**
+     * ID of the last message that was read by the user
+     */
+    private lastReadMessageId;
+    /**
+     * Reference to current messages (injected from outside)
+     */
+    private messagesSignal;
+    /**
+     * Computed number of unread bot messages
+     */
+    unreadCount: Signal<number>;
+    /**
+     * Effect to automatically mark messages as read when chat is opened
+     */
+    markAsReadEffect: _angular_core.EffectRef;
+    /**
+     * Set the messages signal reference from an external source
+     * This allows the UI state service to track messages from MessageService
+     */
+    setMessagesSignal(messagesSignal: Signal<Message[]>): void;
+    /**
+     * Toggle the chat window open/close state
+     */
+    toggleChat(): void;
+    /**
+     * Toggle the history sidebar open/close state
+     */
+    toggleHistorySidebar(): void;
+    /**
+     * Close the chat window
+     */
+    closeChat(): void;
+    /**
+     * Open the chat window
+     */
+    openChat(): void;
+    /**
+     * Close the history sidebar
+     */
+    closeHistorySidebar(): void;
+    /**
+     * Open the history sidebar
+     */
+    openHistorySidebar(): void;
+    /**
+     * Toggle fullscreen mode
+     */
+    toggleFullscreen(): void;
+    /**
+     * Set fullscreen state
+     */
+    setFullscreen(isFullscreen: boolean): void;
+    /**
+     * Manually mark messages as read up to a specific message ID
+     */
+    markMessagesAsRead(messageId: string): void;
+    /**
+     * Reset last read message ID
+     */
+    resetLastRead(): void;
+    /**
+     * Get the last read message ID
+     */
+    getLastReadMessageId(): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatUIStateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChatUIStateService>;
+}
+
+/**
+ * Prompt mode
+ */
+type PromptMode = 'markdown' | 'plain';
+
+/**
+ * Error response from chat API
+ */
+interface ChatApiError {
+    /**
+     * Error message
+     */
+    message: string;
+    /**
+     * Error code
+     */
+    code?: string;
+    /**
+     * HTTP status code
+     */
+    statusCode?: number;
+    /**
+     * Additional error details
+     */
+    details?: any;
+}
+
+interface ChatStreamMessage {
+    role: MessageRole;
+    content: string;
+}
+
+declare class ChatService {
+    private apiService;
+    private authService;
+    private configService;
+    private config;
+    private chatHistoryService;
+    private chatUIStateService;
+    private markdownService;
+    private chatSessions;
+    messages: _angular_core.WritableSignal<Message[]>;
+    /**
+     * Determine if suggestion chips should be shown
+     */
+    showSuggestionChips: _angular_core.Signal<boolean>;
+    private activeSession;
+    isLoadingApi: _angular_core.WritableSignal<boolean>;
+    apiError: _angular_core.WritableSignal<ChatApiError | null>;
+    isBotTyping: _angular_core.WritableSignal<boolean>;
+    promptMode: _angular_core.WritableSignal<PromptMode>;
+    isStreaming: _angular_core.Signal<boolean>;
+    messagesStream: Array<ChatStreamMessage>;
+    currentResponse: string;
+    getFallbackError(): string;
+    constructor();
+    /**
+     * Create a new chat session
+     */
+    createSession(userId: string, sessionId: string): ChatSessionDto;
+    /**
+     * Start a new chat session
+     */
+    startNewSession(sessionId?: string): void;
+    /**
+     * Load an existing session
+     */
+    loadSession(session: ChatSessionDto): void;
+    /**
+     * Get active session
+     */
+    getActiveSession(): ChatSessionDto | null;
+    /**
+     * Clear messages for current session and start new one
+     */
+    clearMessages(): void;
+    /**
+     * Add message to current session
+     */
+    addMessage(message: Message): void;
+    /**
+     * Continue a chat session
+     */
+    continueSession(sessionId: string): Promise<void>;
+    /**
+     * Process a user message: add it, get bot reply, and add bot reply
+     */
+    sendMessage(text: string, maxLength?: number): Promise<void>;
+    /**
+     * Generates a unique message ID to prevent collisions
+     */
+    private generateMessageId;
+    /**
+     * Builds a chat request payload with the given user text and optional active session
+     * @param {string} userInput - The text provided by the user
+     * @returns {ChatRequest} - A chat request payload with the user text and optional active session
+     * @memberof ChatService
+     */
+    private buildChatRequest;
+    /**
+     * Send chat message using standard endpoint and return the response content.
+     */
+    private ask;
+    private stream;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChatService>;
+}
+
+interface DialogData {
+    title: string;
+    message: string;
+    confirmText?: string;
+    cancelText?: string;
+    confirmButtonColor?: 'primary' | 'accent' | 'warn';
+    icon?: string;
+}
+
+interface InputDialogData {
+    title: string;
+    message: string;
+    initialValue: string;
+    placeholder?: string;
+    confirmText?: string;
+    cancelText?: string;
+    confirmButtonColor?: 'primary' | 'accent' | 'warn';
+}
+
+declare class DialogService {
+    private dialog;
+    constructor(dialog: MatDialog);
+    /**
+     * Opens a confirmation dialog with customizable options
+     * @param data Configuration for the dialog
+     * @returns Observable that emits true if confirmed, false if cancelled
+     */
+    open(data: DialogData): Observable<boolean>;
+    /**
+     * Convenience method for delete confirmation dialogs
+     * @param itemName Name of the item being deleted
+     * @returns Observable that emits true if confirmed, false if cancelled
+     */
+    confirmDelete(itemName?: string): Observable<boolean>;
+    /**
+     * Opens a dialog with an input field
+     * @param data Configuration for the input dialog
+     * @returns Observable that emits the input value if confirmed, null if cancelled
+     */
+    openInput(data: InputDialogData): Observable<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DialogService>;
+}
+
+declare class LicenseService {
+    private http;
+    private config;
+    constructor(http: HttpClient, config: DoohbotConfig);
+    /**
+     * Loads license file from a public asset URL.
+     * Library-safe: works only with HTTP-accessible paths.
+     */
+    loadLicenseFile(): Promise<Map<string, string> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LicenseService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LicenseService>;
+}
+
+declare class SnackbarService {
+    private snackBar;
+    constructor(snackBar: MatSnackBar);
+    private show;
+    success(message: string, duration?: number): void;
+    warn(message: string, duration?: number): void;
+    error(message: string, duration?: number): void;
+    info(message: string, duration?: number): void;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SnackbarService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SnackbarService>;
+}
+
+/**
+ * Doohbot Main Component
+ * Root component of the Doohbot library
+ */
+declare class DoohbotComponent implements OnInit, OnDestroy {
+    private elementRef;
+    private renderer;
+    private dialogService;
+    private snackbarService;
+    private chatHistory;
+    private uiState;
+    private themeService;
+    private authService;
+    private chatService;
+    private personalizationService;
+    private licenseService;
+    private configService;
+    /**
+     * Federated authentication token from the host application.
+     *
+     * Used for SSO / federated login. The token must be issued by a
+     * trusted issuer configured in the Doohbot admin panel.
+     *
+     * @example
+     * ```html
+     * <app-doohbot [federatedAuthToken]="authToken"></app-doohbot>
+     * ```
+     */
+    federatedAuthToken?: string;
+    /**
+     * Whether the user session should be persisted across browser restarts.
+     *
+     * When `true`, Doohbot stores auth state in `localStorage`.
+     * When `false`, `sessionStorage` is used instead.
+     *
+     * @example
+     * ```html
+     * <app-doohbot [rememberMe]="true"></app-doohbot>
+     * ```
+     */
+    rememberMe?: boolean;
+    /**
+     * License file json object.
+     *
+     * Required only when the `licenseFilePath` is not passed from `provideDoohbot()`.
+     *
+     * @example
+     * ```html
+     * <app-doohbot [licenseFile]="licenseFile"></app-doohbot>
+     * ```
+     */
+    licenseFile?: Map<string, string>;
+    /**
+     * License code used to activate licensed features.
+     *
+     * Required only when multiple licenses are configured.
+     * Can change dynamically per tenant, user, or role.
+     *
+     * @example
+     * ```html
+     * <app-doohbot [licenseCode]="licenseCode"></app-doohbot>
+     * ```
+     */
+    licenseCode?: string;
+    isChatOpen: _angular_core.WritableSignal<boolean>;
+    isHistorySidebarOpen: _angular_core.WritableSignal<boolean>;
+    isFullScreen: _angular_core.WritableSignal<boolean>;
+    unreadCount: any;
+    messages: _angular_core.WritableSignal<Message[]>;
+    isBotTyping: _angular_core.WritableSignal<boolean>;
+    isStreaming: any;
+    messageError: any;
+    showSuggestionChips: any;
+    chatSessions: _angular_core.WritableSignal<ChatSessionDto[]>;
+    hasMoreHistory: _angular_core.WritableSignal<boolean>;
+    isLoadingMore: _angular_core.WritableSignal<boolean>;
+    isLoadingSessions: _angular_core.WritableSignal<boolean>;
+    processingSessionId: _angular_core.WritableSignal<string | null>;
+    isAuthenticated: _angular_core.WritableSignal<boolean>;
+    isLoggingIn: _angular_core.WritableSignal<boolean>;
+    authError: _angular_core.WritableSignal<string | null>;
+    authSuccess: _angular_core.WritableSignal<string | null>;
+    private destroyIsAuthenticated$;
+    activeButtonStyle: any;
+    get enableDrag(): boolean;
+    get enableResize(): boolean;
+    userName: _angular_core.WritableSignal<string>;
+    predefinedMessages: _angular_core.WritableSignal<string[]>;
+    suggestedMessages: _angular_core.WritableSignal<string[]>;
+    maxMessageLength: _angular_core.WritableSignal<number>;
+    readonly doohbotConst: {
+        appTitle: string;
+        appSubtitle: string;
+        welcomeDescription: string;
+        hintText: string;
+        appLogo: string;
+        appTextLogo: string;
+        appHeaderLogo: string;
+        userAvatar: string;
+        botAvatar: string;
+    };
+    private contextCleanup?;
+    chatWindowRef: ElementRef;
+    fullscreenDirective: FullscreenDirective;
+    constructor(elementRef: ElementRef, renderer: Renderer2, dialogService: DialogService, snackbarService: SnackbarService, chatHistory: ChatHistoryService, uiState: ChatUIStateService, themeService: ThemeService, authService: AuthService, chatService: ChatService, personalizationService: PersonalizationService, licenseService: LicenseService, configService: DoohbotConfigService);
+    ngOnInit(): Promise<void>;
+    ngOnChanges(changes: SimpleChanges): void;
+    initVariableState(): void;
+    private initializeUI;
+    onLogin(param: LoginRequest): void;
+    performLogout(): void;
+    toggleChat(): void;
+    sendMessage(text: string): Promise<void>;
+    clearChat(): void;
+    clearMessageError(): void;
+    toggleHistorySidebar(): void;
+    loadChatSession(session: ChatSessionDto): void;
+    deleteSession(sessionId: string): Promise<void>;
+    deleteAllSessions(): Promise<void>;
+    renameSession(event: {
+        sessionId: string;
+        newTitle: string;
+    }): Promise<void>;
+    private loadUserSessions;
+    /**
+     * Load more sessions for infinite scroll
+     */
+    loadMoreHistory(): Promise<void>;
+    /**
+     * Manually refresh history
+     */
+    refreshHistory(): Promise<void>;
+    toggleFullScreen(): void;
+    trackByMessageId(index: number, item: any): string;
+    /**
+     * Resolve and update the username from all available sources
+     */
+    updateUserName(): void;
+    userAvatarUrl(): string;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DoohbotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DoohbotComponent, "app-doohbot", never, { "federatedAuthToken": { "alias": "federatedAuthToken"; "required": false; }; "rememberMe": { "alias": "rememberMe"; "required": false; }; "licenseFile": { "alias": "licenseFile"; "required": false; }; "licenseCode": { "alias": "licenseCode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class Logger {
+    private configService;
+    private static instance;
+    private prefix;
+    private styles;
+    constructor(configService: DoohbotConfigService);
+    /** bind once */
+    static init(instance: Logger): void;
+    private canLog;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    private static get logger();
+    static info(message: string, ...args: unknown[]): void;
+    static warn(message: string, ...args: unknown[]): void;
+    static error(message: string, ...args: unknown[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Logger, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<Logger>;
+}
+
+/**
+ * Provides all necessary Doohbot dependencies for standalone Angular applications.
+ *
+ * This provider:
+ * - Registers the Doohbot configuration via dependency injection
+ * - Registers HTTP interceptors required for authentication and licensing
+ * - Does NOT provide `HttpClientModule` — the host application must provide it
+ *
+ * Use this when you want Doohbot to manage authentication, licensing,
+ * and API integration automatically.
+ *
+ * @param config Partial configuration. Missing values are resolved using library defaults.
+ * @returns EnvironmentProviders for use with `bootstrapApplication`
+ *
+ * @example
+ * ```ts
+ * // main.ts
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { importProvidersFrom } from '@angular/core';
+ * import { HttpClientModule } from '@angular/common/http';
+ * import { AppComponent } from './app/app.component';
+ * import { provideDoohbot } from 'doohbot';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     importProvidersFrom(HttpClientModule),
+ *     provideDoohbot({
+ *       environment: 'production',
+ *       licenseFilePath: 'assets/doohbot_license.json',
+ *       // Optional api configuration if want to use your own api
+ *       api: {
+ *         apiBaseUrl: 'https://api.doohbot.com/',
+ *         apiKey: 'your-api-key',
+ *       },
+ *       // Optional theme configuration if want to match doohbot to your application theme
+ *       theme: {
+ *         buttonStyle: 'fab',
+ *         primaryColor: '#4f46e5',
+ *         backgroundColor: '#ffffff',
+ *         textColor: '#111827',
+ *         fontFamily: 'Inter, Roboto, sans-serif',
+ *         enableDrag: true,
+ *         enableResize: true
+ *       }
+ *     }),
+ *   ],
+ * }).catch(console.error);
+ * ```
+ */
+declare function provideDoohbot(config?: Partial<DoohbotConfig>): _angular_core.EnvironmentProviders;
+
+/**
+ * Injection token for Doohbot configuration.
+ * Used to inject user-provided or default config into services.
+ */
+declare const DOOHBOT_CONFIG: InjectionToken<DoohbotConfig>;
+
+/**
+ * Merges user-provided config overrides with defaults.
+ *
+ * @param overrides - Partial config to override defaults
+ * @returns Fully resolved DoohbotConfig object
+ */
+declare function resolveDoohbotConfig(overrides?: Partial<DoohbotConfig>): DoohbotConfig;
+
+declare const doohbotConst: {
+    appTitle: string;
+    appSubtitle: string;
+    welcomeDescription: string;
+    hintText: string;
+    appLogo: string;
+    appTextLogo: string;
+    appHeaderLogo: string;
+    userAvatar: string;
+    botAvatar: string;
+};
+
+export { DOOHBOT_CONFIG, DoohbotComponent, DoohbotConfigService, Logger, doohbotConst, provideDoohbot, resolveDoohbotConfig };
+export type { DoohbotApiConfig, DoohbotConfig, DoohbotThemeConfig };
+//# sourceMappingURL=index.d.ts.map