@aakash58/chatbot 1.1.21 → 1.1.22

package/lib/core/interceptors/auth.interceptor.d.ts

@@ -0,0 +1,18 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { StorageService } from '../auth/storage.service';
+import { Injector } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AuthInterceptor implements HttpInterceptor {
+    private tokenStorage;
+    private injector;
+    private isRefreshing;
+    private clearingAuth;
+    private refreshTokenSubject;
+    constructor(tokenStorage: StorageService, injector: Injector);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    private handle401Error;
+    getRequestWithHeaders(req: HttpRequest<any>): HttpRequest<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthInterceptor>;
+}

package/lib/core/interceptors/license.interceptor.d.ts

@@ -0,0 +1,11 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class LicenseInterceptor implements HttpInterceptor {
+    private injector;
+    constructor(injector: Injector);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LicenseInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LicenseInterceptor>;
+}

package/lib/core/models/api-config.model.d.ts

@@ -0,0 +1,58 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Configuration for Doohbot API integration
+ */
+export interface DoohbotApiConfig {
+    /**
+     * Backend API endpoint URL
+     * Example: 'https://api.example.com/chat'
+     */
+    apiUrl: string;
+    /**
+     * Optional API key for authentication
+     */
+    apiKey?: string;
+    /**
+     * Request timeout in milliseconds
+     * @default 30000 (30 seconds)
+     */
+    timeout?: number;
+    /**
+     * Enable API mode (true) or use local intent matching (false)
+     * @default false
+     */
+    enableApi?: boolean;
+    /**
+     * Include message history in API requests
+     * @default false
+     */
+    includeHistory?: boolean;
+    /**
+     * Maximum number of history messages to include in requests
+     * @default 10
+     */
+    maxHistoryMessages?: number;
+    /**
+     * Custom headers to include in API requests
+     */
+    customHeaders?: Record<string, string>;
+    /**
+     * Enable retry on failure
+     * @default true
+     */
+    enableRetry?: boolean;
+    /**
+     * Number of retry attempts
+     * @default 2
+     */
+    retryAttempts?: number;
+    /**
+     * Delay between retries in milliseconds
+     * @default 1000
+     */
+    retryDelay?: number;
+}
+/**
+ * Injection token for providing Doohbot API configuration
+ */
+export declare const DOOHBOT_API_CONFIG: InjectionToken<DoohbotApiConfig>;

package/lib/core/models/api-request.model.d.ts

@@ -0,0 +1,77 @@
+import { PromptMode } from '../types/prompt-mode.type';
+import { Message } from './message';
+/**
+ * Request payload for chat API
+ */
+export interface ChatApiRequest {
+    /**
+     * User's message text
+     */
+    message: string;
+    /**
+     * Prompt mode
+     */
+    prompt_mode?: PromptMode;
+    /**
+     * Optional message history for context
+     */
+    history?: Message[];
+    /**
+     * Optional metadata
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Timestamp of the request
+     */
+    timestamp?: string;
+}
+/**
+ * Response from chat API
+ */
+export interface ChatApiResponse {
+    /**
+     * Bot's reply message
+     */
+    reply: string;
+    /**
+     * Optional confidence score (0-1)
+     */
+    confidence?: number;
+    /**
+     * Whether to show suggestion chips
+     */
+    showSuggestions?: boolean;
+    /**
+     * Optional suggested responses
+     */
+    suggestions?: string[];
+    /**
+     * Optional metadata from the API
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Optional message ID from the backend
+     */
+    messageId?: string;
+}
+/**
+ * Error response from chat API
+ */
+export interface ChatApiError {
+    /**
+     * Error message
+     */
+    message: string;
+    /**
+     * Error code
+     */
+    code?: string;
+    /**
+     * HTTP status code
+     */
+    statusCode?: number;
+    /**
+     * Additional error details
+     */
+    details?: any;
+}

package/lib/core/models/api-response.model.d.ts

@@ -0,0 +1,6 @@
+export declare class ApiResponse<T> {
+    success: boolean;
+    message: string;
+    data?: T;
+    constructor(success: boolean, message: string, data?: T);
+}

package/lib/core/models/doohbot-config.model.d.ts

@@ -0,0 +1,81 @@
+import { InjectionToken } from '@angular/core';
+import { AuthMode } from '../types/auth-mode.type';
+import { TenantResolutionStrategy } from '../types/tenant-resolution-strategy.type';
+import { PromptMode } from '../types/prompt-mode.type';
+/**
+ * Advanced configuration for DoohBot package
+ * Supports both simple and complex use cases
+ */
+export interface DoohbotAdvancedConfig {
+    /**
+     * Authentication mode
+     * - 'manual': You provide platformTenant, subTenant, agent manually
+     * - 'auto': Package reads from your auth service via resolver
+     * @default 'manual'
+     */
+    authMode?: AuthMode;
+    /**
+     * Tenant resolution strategy
+     * - 'static': Use fixed values provided via inputs
+     * - 'dynamic': Automatically update when auth state changes
+     * - 'callback': Use custom resolver function
+     * @default 'static'
+     */
+    tenantResolution?: TenantResolutionStrategy;
+    /**
+     * Auto-configure from localStorage key
+     * If provided, package will read auth data from localStorage
+     * Example: 'auth_user' or 'saas_session'
+     */
+    autoConfigFromStorage?: string;
+    /**
+     * Enable multi-tenant mode
+     * Allows switching between different tenant contexts
+     * @default false
+     */
+    enableMultiTenant?: boolean;
+    /**
+     * Persist chat history per tenant
+     * @default true
+     */
+    persistChatPerTenant?: boolean;
+    /**
+     * Custom authentication header name
+     * @default 'Authorization'
+     */
+    authHeaderName?: string;
+    /**
+     * Custom authentication header format
+     * Use {token} as placeholder
+     * @default 'Bearer {token}'
+     */
+    authHeaderFormat?: string;
+    /**
+     * Enable role-based features
+     * Shows/hides features based on user permissions
+     * @default false
+     */
+    enableRoleBasedFeatures?: boolean;
+    /**
+     * User permissions (for role-based features)
+     */
+    userPermissions?: string[];
+    /**
+     * Callback when authentication fails
+     */
+    onAuthFailure?: (error: any) => void;
+    /**
+     * Enable debug mode (logs configuration and requests)
+     * @default false
+     */
+    debugMode?: boolean;
+    /**
+     * Prompt mode for chat responses
+     * @default 'markdown'
+     */
+    promptMode?: PromptMode;
+}
+/**
+ * Injection token for advanced configuration
+ */
+export declare const DOOHBOT_ADVANCED_CONFIG: InjectionToken<DoohbotAdvancedConfig>;

package/{projects/doohbot/src/lib/core/models/license.model.ts → lib/core/models/license.model.d.ts}

@@ -1,27 +1,23 @@
-export interface LicensingContext {
-    tenantId: string;    // Unique company/org ID
-    principalId: string; // User / Merchant ID
-    roles?: string[];    // Optional roles/groups
-}
-
-export interface LicensePackage {
-    [packageId: string]: string; // packageId -> licenseKey
-}
-
-export interface SubjectLicense {
-    subjectType: 'user' | 'role' | 'tenant';
-    subjectId: string;
-    packages: LicensePackage;
-}
-
-export interface LicenseFileContent {
-    accountId: string;
-    issuedBy: string;
-    issuedAt: string;
-    licenses: SubjectLicense[];
-}
-
-export interface LicenseRegistry {
-    accountId: string;
-    subjectLicenses: Map<string, LicensePackage>;
-}
+export interface LicensingContext {
+    tenantId: string;
+    principalId: string;
+    roles?: string[];
+}
+export interface LicensePackage {
+    [packageId: string]: string;
+}
+export interface SubjectLicense {
+    subjectType: 'user' | 'role' | 'tenant';
+    subjectId: string;
+    packages: LicensePackage;
+}
+export interface LicenseFileContent {
+    accountId: string;
+    issuedBy: string;
+    issuedAt: string;
+    licenses: SubjectLicense[];
+}
+export interface LicenseRegistry {
+    accountId: string;
+    subjectLicenses: Map<string, LicensePackage>;
+}

package/lib/core/models/message.d.ts

@@ -0,0 +1,16 @@
+import { MessageRole } from '../types/message-role.type';
+export interface Message {
+    id: string;
+    sender: MessageRole;
+    senderName?: string;
+    text: string;
+    chunks?: string[];
+    timestamp?: Date;
+    showSuggestions?: boolean;
+    platformTenant?: string;
+    subTenant?: string;
+    agent?: string;
+    completed: boolean | true;
+    isHistory: boolean | true;
+    copied?: boolean;
+}

package/lib/core/models/theme-config.model.d.ts

@@ -0,0 +1,28 @@
+export interface DoohbotThemeConfig {
+    fontFamily?: string;
+    primaryColor?: string;
+    secondaryColor?: string;
+    backgroundColor?: string;
+    chatInputColor?: string;
+    textAltColor?: string;
+    textColor?: string;
+    secondaryTextColor?: string;
+    hintTextColor?: string;
+    buttonColor?: string;
+    userMessageColor?: string;
+    botMessageColor?: string;
+    userTextColor?: string;
+    botTextColor?: string;
+    borderColor?: string;
+    borderShadowColor?: string;
+    borderTopColor?: string;
+    typingIndicatorColor?: string;
+    white?: string;
+    black?: string;
+    grey?: string;
+    red?: string;
+    yellow?: string;
+    orange?: string;
+    green?: string;
+    blue?: string;
+}

package/lib/core/services/core-config.service.d.ts

@@ -0,0 +1,23 @@
+import { DoohbotInput } from '../../doohbot-input';
+import * as i0 from "@angular/core";
+export declare class CoreConfigService {
+    private configSignal;
+    config$: import("@angular/core").Signal<DoohbotInput>;
+    /**
+     * Updates the global library configuration
+     */
+    updateConfig(config: DoohbotInput): void;
+    /**
+     * Dynamic getters for common config properties
+     */
+    get apiUrl(): string;
+    get storageKey(): string;
+    get secretKey(): string;
+    get companyCode(): string;
+    get tenancyName(): string;
+    get licenseKey(): string;
+    get licenseFilePath(): string;
+    get rememberMe(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CoreConfigService>;
+}

package/lib/core/services/license.service.d.ts

@@ -0,0 +1,33 @@
+import { LicensingContext } from '../models/license.model';
+import * as i0 from "@angular/core";
+export declare class LicenseService {
+    private http;
+    private coreConfig;
+    private registry;
+    /**
+     * Load the license configuration from a JSON file.
+     * Supports both Hierarchical (entitlements) and Flat-map (package:key) formats.
+     * @param filePath Path to the license JSON file
+     */
+    loadLicenseFile(filePath?: string): Promise<void>;
+    private processHierarchicalLicense;
+    private processFlatMapLicense;
+    /**
+     * Resolve the correct license key based on context and requested package
+     * @param context The current licensing context (tenant, user, roles)
+     * @param packageId The ID of the package requesting a license
+     * @returns The resolved license key, or null if unauthorized
+     */
+    resolveLicenseKey(context: LicensingContext, packageId: string): string | null;
+    private resolveFromRegistry;
+    /**
+     * Resolves the license key for the current tenant.
+     */
+    resolveTenantLicenseKey(tenancyName?: string): string | null;
+    /**
+     * Check if a registry is currently loaded
+     */
+    isRegistryLoaded(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LicenseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LicenseService>;
+}

package/lib/core/services/markdown.service.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class MarkdownService {
+    constructor();
+    convert(markdown: string): string;
+    private escapeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MarkdownService>;
+}

package/lib/core/services/theme.service.d.ts

@@ -0,0 +1,40 @@
+import { OnDestroy, RendererFactory2 } from '@angular/core';
+import { OverlayContainer } from '@angular/cdk/overlay';
+import { DoohbotThemeConfig } from '../models/theme-config.model';
+import { PersonalizationService } from '../../app/personalization/personalization.service';
+import * as i0 from "@angular/core";
+export type ThemeMode = 'light' | 'dark' | 'auto';
+export declare class ThemeService implements OnDestroy {
+    private overlay;
+    private personalization;
+    private renderer;
+    private _theme;
+    theme: import("@angular/core").Signal<ThemeMode>;
+    private _activeTheme;
+    activeTheme: import("@angular/core").Signal<"light-theme" | "dark-theme">;
+    private observer;
+    constructor(rendererFactory: RendererFactory2, overlay: OverlayContainer, personalization: PersonalizationService);
+    private _currentConfig;
+    private rootElement;
+    setThemeConfig(config: DoohbotThemeConfig, rootElement: HTMLElement): void;
+    applyPrimaryColorToGlobal(colorInput: string): void;
+    /**
+     * 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 cleanupObservers;
+    ngOnDestroy(): void;
+    /**
+     * @deprecated Manual CSS variable application is now handled via theme.css tokens
+     */
+    applyCssVariables(element: HTMLElement, config: DoohbotThemeConfig | undefined): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+}

package/{projects/doohbot/src/lib/core/types/auth-mode.type.ts → lib/core/types/auth-mode.type.d.ts}

@@ -1,4 +1,4 @@
-/**
- * Authentication mode for the chatbot
- */
-export type AuthMode = 'manual' | 'auto';
+/**
+ * Authentication mode for the chatbot
+ */
+export type AuthMode = 'manual' | 'auto';

package/{projects/doohbot/src/lib/core/types/auth-status.type.ts → lib/core/types/auth-status.type.d.ts}

@@ -1,5 +1,4 @@
-/**
- * Authentication status
- */
-
-export type AuthStatus = 'authenticated' | 'unauthenticated' | 'expired';
+/**
+ * Authentication status
+ */
+export type AuthStatus = 'authenticated' | 'unauthenticated' | 'expired';

package/{projects/doohbot/src/lib/core/types/chat-stream.type.ts → lib/core/types/chat-stream.type.d.ts}

@@ -1,4 +1,4 @@
-/**
- * Chat stream type
- */
-export type ChatStream = 'chunk' | 'complete' | 'error';
+/**
+ * Chat stream type
+ */
+export type ChatStream = 'chunk' | 'complete' | 'error';

package/{projects/doohbot/src/lib/core/types/message-role.type.ts → lib/core/types/message-role.type.d.ts}

@@ -1,4 +1,4 @@
-/**
- * Message role types for chat messages
- */
-export type MessageRole = 'user' | 'assistant';
+/**
+ * Message role types for chat messages
+ */
+export type MessageRole = 'user' | 'assistant';

package/{projects/doohbot/src/lib/core/types/prompt-mode.type.ts → lib/core/types/prompt-mode.type.d.ts}

@@ -1,5 +1,4 @@
-/**
- * Prompt mode
- */
-
-export type PromptMode = 'markdown' | 'plain';
+/**
+ * Prompt mode
+ */
+export type PromptMode = 'markdown' | 'plain';

package/{projects/doohbot/src/lib/core/types/snackbar-error.type.ts → lib/core/types/snackbar-error.type.d.ts}

@@ -1,5 +1,4 @@
-/**
- * Error types for snackbar
- */
-
-export type SnackBarError = 'warn' | 'error' | 'success' | 'info';
+/**
+ * Error types for snackbar
+ */
+export type SnackBarError = 'warn' | 'error' | 'success' | 'info';

package/{projects/doohbot/src/lib/core/types/tenant-resolution-strategy.type.ts → lib/core/types/tenant-resolution-strategy.type.d.ts}

@@ -1,4 +1,4 @@
-/**
- * Tenant resolution strategy
- */
-export type TenantResolutionStrategy = 'static' | 'dynamic' | 'callback';
+/**
+ * Tenant resolution strategy
+ */
+export type TenantResolutionStrategy = 'static' | 'dynamic' | 'callback';

package/lib/core/utils/logger.service.d.ts

@@ -0,0 +1,11 @@
+declare class Logger {
+    private static prefix;
+    private static styles;
+    private static canLog;
+    static log(message: string, ...args: any[]): void;
+    static info(message: string, ...args: any[]): void;
+    static warn(message: string, ...args: any[]): void;
+    static error(message: string, ...args: any[]): void;
+    static debug(message: string, ...args: any[]): void;
+}
+export default Logger;

package/lib/doohbot-input.d.ts

@@ -0,0 +1,19 @@
+export declare class DoohbotInput {
+    username: string;
+    password: string;
+    rememberMe?: boolean;
+    authToken?: string;
+    license?: string;
+    licenseCode?: string;
+    licenseKey?: string;
+    licenseFilePath?: string;
+    apiBaseUrl?: string;
+    apiSegment?: string;
+    tenancyName?: string;
+    storageKey?: string;
+    secretKey?: string;
+    companyCode?: string;
+    buttonStyle?: 'fab' | 'sidebar' | 'sidebar-top' | 'sidebar-bottom';
+    primaryColor?: string;
+    accentColor?: string;
+}