@aakash58/chatbot 1.1.21 → 1.1.22

package/lib/app/chat/services/chat-history.service.d.ts

@@ -0,0 +1,53 @@
+import { Observable } from 'rxjs';
+import { ChatSession } from '../model/chat-session.model';
+import { Message } from '../../../core/models/message';
+import { ChatSessionResponse } from '../model/chat-history.model';
+import * as i0 from "@angular/core";
+export declare class ChatHistoryService {
+    private chatApiService;
+    sessions: import("@angular/core").WritableSignal<ChatSession[]>;
+    isLoading: import("@angular/core").WritableSignal<boolean>;
+    isLoadingMore: import("@angular/core").WritableSignal<boolean>;
+    hasMore: import("@angular/core").WritableSignal<boolean>;
+    historyOffset: import("@angular/core").WritableSignal<number>;
+    isCacheValid: import("@angular/core").WritableSignal<boolean>;
+    processingSessionId: import("@angular/core").WritableSignal<string | null>;
+    /**
+     * Map API session response to ChatSession model
+     */
+    mapSessionResponseToSession(sessionResponse: ChatSessionResponse, userId: string): ChatSession;
+    /**
+     * Load all chat sessions for a specific user
+     */
+    loadSessions(userId: string, forceRefresh?: boolean): void;
+    /**
+     * Load more sessions for infinite scroll
+     */
+    loadMoreSessions(userId: string): void;
+    /**
+     * Load messages for a specific session
+     */
+    loadSessionMessages(sessionId: string): Observable<Message[]>;
+    /**
+     * Delete a specific session
+     */
+    deleteSession(sessionId: string, userId: string): Observable<void>;
+    /**
+     * Delete all history
+     */
+    deleteAllHistory(userId: string): Observable<void>;
+    /**
+     * Update session title
+     */
+    updateSessionTitle(sessionId: string, newTitle: string, userId: string): Observable<boolean>;
+    /**
+     * Invalidate cache
+     */
+    invalidateCache(): void;
+    /**
+     * Clear all history state
+     */
+    clearState(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatHistoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatHistoryService>;
+}

package/lib/app/login/login-form.component.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class LoginFormComponent {
+    isLoggingIn: boolean;
+    loginSubmit: EventEmitter<{
+        username: string;
+        password: string;
+        rememberMe: boolean;
+    }>;
+    cancel: EventEmitter<void>;
+    loginUsername: string;
+    loginPassword: string;
+    showPassword: boolean;
+    rememberMe: boolean;
+    togglePasswordVisibility(): void;
+    onLoginSubmit(): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoginFormComponent, "app-login-form", never, { "isLoggingIn": { "alias": "isLoggingIn"; "required": false; }; }, { "loginSubmit": "loginSubmit"; "cancel": "cancel"; }, never, never, true, never>;
+}

package/lib/app/personalization/personalization-dialog.component.d.ts

@@ -0,0 +1,53 @@
+import { OnDestroy } from '@angular/core';
+import { PersonalizationService, PersonalizationSettings } from './personalization.service';
+import * as i0 from "@angular/core";
+export declare class PersonalizationDialogComponent implements OnDestroy {
+    private dialogRef;
+    private dialogService;
+    personalization: PersonalizationService;
+    private authService;
+    private chatHistory;
+    private snackbar;
+    settings: PersonalizationSettings;
+    activeSection: string;
+    sections: ({
+        id: string;
+        label: string;
+        type: string;
+        icon?: undefined;
+    } | {
+        id: string;
+        label: string;
+        icon: string;
+        type: string;
+    })[];
+    colorTokens: {
+        name: string;
+        value: string;
+    }[];
+    private themeService;
+    private originalColor;
+    private isSaved;
+    constructor();
+    onSave(): void;
+    onCancel(): void;
+    ngOnDestroy(): void;
+    onReset(): void;
+    selectTheme(theme: 'light' | 'dark' | 'auto'): void;
+    selectColor(color: string): void;
+    selectButtonStyle(style: 'fab' | 'sidebar' | 'sidebar-top' | 'sidebar-bottom'): void;
+    selectSection(sectionId: string): void;
+    get hasChanges(): boolean;
+    hasPreferencesChanges(): boolean;
+    hasInstructionChanges(): boolean;
+    get username(): string;
+    get userImageUrl(): string | null;
+    get userRole(): string;
+    isCustomColorSelected(): boolean;
+    onCustomColorChange(event: Event): void;
+    deleteAllHistory(): void;
+    logoutAllDevices(): void;
+    deleteAccount(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PersonalizationDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PersonalizationDialogComponent, "app-personalization-dialog", never, {}, {}, never, never, true, never>;
+}

package/lib/app/personalization/personalization.service.d.ts

@@ -0,0 +1,66 @@
+import * as i0 from "@angular/core";
+export interface Characteristics {
+    warm: string;
+    enthusiastic: string;
+    headersAndLists: string;
+    emoji: string;
+}
+export interface AboutYou {
+    nickname: string;
+    occupation: string;
+}
+export interface CustomInstructions {
+    enabled: boolean;
+    aboutUser: string;
+    responseStyle: string;
+    characteristics: Characteristics;
+    aboutYou: AboutYou;
+}
+export interface AppearanceSettings {
+    theme: 'light' | 'dark' | 'auto';
+    primaryColor: string;
+    buttonStyle: 'fab' | 'sidebar' | 'sidebar-top' | 'sidebar-bottom';
+}
+export interface PersonalizationSettings {
+    customInstructions: CustomInstructions;
+    appearance: AppearanceSettings;
+    meta: {
+        version: number;
+        lastUpdated: number;
+    };
+}
+export declare class PersonalizationService {
+    private storage;
+    private authService;
+    private authStatus;
+    private _settings;
+    settings: import("@angular/core").Signal<PersonalizationSettings>;
+    private _developerDefaults;
+    readonly developerDefaults: import("@angular/core").Signal<Partial<AppearanceSettings>>;
+    constructor();
+    private getStorageKey;
+    /**
+     * Update custom instructions
+     */
+    updateInstructions(instructions: Partial<CustomInstructions>): void;
+    /**
+     * Update appearance settings
+     */
+    updateAppearance(appearance: Partial<AppearanceSettings>): void;
+    /**
+     * Set initial developer defaults (called from DoohbotComponent)
+     */
+    setDeveloperDefaults(defaults: Partial<AppearanceSettings>): void;
+    /**
+     * Reset all personalization to defaults
+     */
+    resetToDefaults(): void;
+    /**
+     * Get the formatted instructions block for chat requests
+     */
+    getFormattedInstructions(): string;
+    private loadSettings;
+    private saveSettings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PersonalizationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PersonalizationService>;
+}

package/lib/app/personalization/sections/account/account-section.component.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface ActiveSession {
+    id: string;
+    device: string;
+    location: string;
+    created: string;
+    updated: string;
+    isCurrent?: boolean;
+}
+export declare class AccountSectionComponent {
+    private dialogService;
+    private authService;
+    private cd;
+    organizationId: string;
+    isCopied: boolean;
+    ngOnInit(): void;
+    onDeleteAllHistory: EventEmitter<void>;
+    onLogoutAll: EventEmitter<void>;
+    onLogoutSession: EventEmitter<string>;
+    onDeleteAccount: EventEmitter<void>;
+    sessions: ActiveSession[];
+    copyOrgId(): void;
+    confirmLogoutAll(): void;
+    confirmLogoutSession(session: ActiveSession): void;
+    confirmDeleteAllHistory(): void;
+    confirmDeleteAccount(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccountSectionComponent, "app-account-section", never, { "organizationId": { "alias": "organizationId"; "required": false; }; }, { "onDeleteAllHistory": "onDeleteAllHistory"; "onLogoutAll": "onLogoutAll"; "onLogoutSession": "onLogoutSession"; "onDeleteAccount": "onDeleteAccount"; }, never, never, true, never>;
+}

package/lib/app/personalization/sections/preferences/color-picker-dialog.component.d.ts

@@ -0,0 +1,17 @@
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+export declare class ColorPickerDialogComponent {
+    dialogRef: MatDialogRef<ColorPickerDialogComponent>;
+    data: {
+        color: string;
+    };
+    color: string;
+    constructor(dialogRef: MatDialogRef<ColorPickerDialogComponent>, data: {
+        color: string;
+    });
+    onColorInput(event: any): void;
+    onCancel(): void;
+    onConfirm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorPickerDialogComponent, "app-color-picker-dialog", never, {}, {}, never, never, true, never>;
+}

package/lib/app/personalization/sections/preferences/preferences-section.component.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { PersonalizationSettings } from '../../personalization.service';
+import * as i0 from "@angular/core";
+export declare class PreferencesSectionComponent {
+    private dialog;
+    constructor(dialog: MatDialog);
+    settings: PersonalizationSettings;
+    colorTokens: any[];
+    isCustomColorSelected: boolean;
+    defaultColor: string;
+    onThemeSelect: EventEmitter<"auto" | "light" | "dark">;
+    onColorSelect: EventEmitter<string>;
+    onButtonStyleSelect: EventEmitter<"fab" | "sidebar" | "sidebar-top" | "sidebar-bottom">;
+    onSave: EventEmitter<void>;
+    onReset: EventEmitter<void>;
+    onCustomColorChange(event: Event): void;
+    getSelectedColorName(): string;
+    isCustomColor(): boolean;
+    getThemeIcon(theme: string): string;
+    getThemeLabel(theme: string): string;
+    getStyleIcon(style: string): string;
+    getStyleLabel(style: string): string;
+    openCustomColorPicker(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreferencesSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PreferencesSectionComponent, "app-preferences-section", never, { "settings": { "alias": "settings"; "required": false; }; "colorTokens": { "alias": "colorTokens"; "required": false; }; "isCustomColorSelected": { "alias": "isCustomColorSelected"; "required": false; }; "defaultColor": { "alias": "defaultColor"; "required": false; }; }, { "onThemeSelect": "onThemeSelect"; "onColorSelect": "onColorSelect"; "onButtonStyleSelect": "onButtonStyleSelect"; "onSave": "onSave"; "onReset": "onReset"; }, never, never, true, never>;
+}

package/lib/app/personalization/sections/profile/profile-section.component.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+export declare class ProfileSectionComponent {
+    username: string;
+    userImageUrl: string | null;
+    userRole: string;
+    appEntity: {
+        amp: string;
+        lt: string;
+        gt: string;
+        quot: string;
+        apos: string;
+        at: string;
+    };
+    get initials(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProfileSectionComponent, "app-profile-section", never, { "username": { "alias": "username"; "required": false; }; "userImageUrl": { "alias": "userImageUrl"; "required": false; }; "userRole": { "alias": "userRole"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/app/personalization/sections/settings/setting-section.component.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '@angular/core';
+import { PersonalizationSettings } from '../../personalization.service';
+import * as i0 from "@angular/core";
+export declare class SettingSectionComponent {
+    settings: PersonalizationSettings;
+    hasChanges: boolean;
+    onSave: EventEmitter<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SettingSectionComponent, "app-setting-section", never, { "settings": { "alias": "settings"; "required": false; }; "hasChanges": { "alias": "hasChanges"; "required": false; }; }, { "onSave": "onSave"; }, never, never, true, never>;
+}

package/lib/app/personalization/sections/terms/terms-section.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class TermsSectionComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TermsSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TermsSectionComponent, "app-terms-section", never, {}, {}, never, never, true, never>;
+}

package/lib/constant/doohbot-constant.d.ts

@@ -0,0 +1,12 @@
+export declare const DoohbotConst: {
+    appTitle: string;
+    appSubtitle: string;
+    welcomeDescription: string;
+    hintText: string;
+    errorMessage: string;
+    appLogo: string;
+    appTextLogo: string;
+    appHeaderLogo: string;
+    userAvatar: string;
+    botAvatar: string;
+};

package/lib/constant/html-entities.d.ts

@@ -0,0 +1,8 @@
+export declare const AppEntity: {
+    amp: string;
+    lt: string;
+    gt: string;
+    quot: string;
+    apos: string;
+    at: string;
+};

package/lib/constant/utf8.d.ts

@@ -0,0 +1,9 @@
+export declare const AppEmoji: {
+    waveHand: string;
+    robotFace: string;
+    partyPopper: string;
+    thinkingFace: string;
+    thumbsUp: string;
+    thumbsDown: string;
+    redHeart: string;
+};

package/lib/core/app-const.d.ts

@@ -0,0 +1,11 @@
+import { ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class AppConst {
+    static appBaseUrl: string;
+    static data: any;
+    config$: ReplaySubject<any>;
+    constructor();
+    load(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppConst, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppConst>;
+}

package/lib/core/auth/account-api.service.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { HttpService } from '../http/http.service';
+import { AuthResult } from './models/auth-result.model';
+import { ApiResponse } from '../models/api-response.model';
+import { LoginRequest } from './models/login-request.model';
+import { FederatedLoginRequest } from './models/federated-login-request.model';
+import { StorageService } from './storage.service';
+import * as i0 from "@angular/core";
+export declare class AccountService {
+    private http;
+    private tokenStorage;
+    constructor(http: HttpService, tokenStorage: StorageService);
+    login(param?: LoginRequest, showLoader?: boolean): Observable<ApiResponse<AuthResult>>;
+    federateLogin(param?: FederatedLoginRequest, showLoader?: boolean): Observable<ApiResponse<AuthResult>>;
+    private buildLicenceHeader;
+    refreshLogin(param?: object, showLoader?: boolean): Observable<ApiResponse<AuthResult>>;
+    logout(refreshToken: string, showLoader?: boolean): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AccountService>;
+}

package/lib/core/auth/auth.service.d.ts

@@ -0,0 +1,90 @@
+import { CoreConfigService } from '../services/core-config.service';
+import { DoohbotInput } from '../../doohbot-input';
+import { Observable } from 'rxjs';
+import { AuthResult } from './models/auth-result.model';
+import { FederatedLoginRequest } from './models/federated-login-request.model';
+import { LoginRequest } from './models/login-request.model';
+import { JwtHelperService } from '@auth0/angular-jwt';
+import { CryptoHelperService } from '../helpers/crypto-helper.service';
+import { StorageService } from './storage.service';
+import { AuthStatus } from '../types/auth-status.type';
+import { AccountService } from './account-api.service';
+import { Router } from '@angular/router';
+import { LicensingContext } from '../models/license.model';
+import * as i0 from "@angular/core";
+declare global {
+    interface Window {
+        storageEventAdded?: boolean;
+        tabCLoseEventAdded?: boolean;
+        abp?: any;
+        AppPreBootstrap?: any;
+        AppConsts?: any;
+    }
+}
+export declare class AuthService {
+    private accountService;
+    private cryptoHelper;
+    private tokenStorage;
+    private router;
+    private coreConfig;
+    get apiUrl(): string;
+    get storageKey(): string;
+    get secretKey(): string;
+    get companyCode(): string;
+    jwtHelper: JwtHelperService;
+    private advancedConfig;
+    private authStatusSubject;
+    authStatus$: Observable<AuthStatus>;
+    isLoggingIn: import("@angular/core").WritableSignal<boolean>;
+    authError: import("@angular/core").WritableSignal<string | null>;
+    authSuccess: import("@angular/core").WritableSignal<string | null>;
+    constructor(accountService: AccountService, cryptoHelper: CryptoHelperService, tokenStorage: StorageService, router: Router, coreConfig: CoreConfigService);
+    /**
+     * Updates the service configuration from the component input
+     */
+    updateConfig(config: DoohbotInput): void;
+    getLoggedInUserName(): string;
+    getLoggedInUserImageUrl(): string | null;
+    getLoggedInUserRole(): string;
+    get authStatus(): AuthStatus;
+    /**
+     * Resolves a federated token from browser storage
+     */
+    private resolveSilentToken;
+    /**
+     * Authenticate user with federated credentials
+     */
+    federatedLogin(credentials: Partial<FederatedLoginRequest>, silent?: boolean): Promise<boolean>;
+    /**
+     * Authenticate user with credentials
+     */
+    login(credentials: LoginRequest, silent?: boolean): Promise<boolean>;
+    logout(refreshToken?: string): Promise<boolean>;
+    setSession(session: AuthResult, rememberMe?: boolean): void;
+    getOrganizationId(): string | null;
+    getRefreshToken(): string | null;
+    refreshToken(): Observable<AuthResult>;
+    isAuthenticated(): boolean;
+    isTokenExpired(): boolean;
+    /**
+     * Validate stored token on app startup
+     */
+    validateStoredToken(): Observable<AuthStatus>;
+    getUserId(): any;
+    getLicensingContext(): LicensingContext;
+    get licenseKey(): string;
+    get isFederated(): boolean;
+    setLicenseKey(key: string): void;
+    /**
+     * Clear all authentication related data from local storage, session storage, cache, and tokens.
+     * This method is called when the user logs out.
+     */
+    clearAuth(): void;
+    clearSession(): void;
+    clearTabInfo(): void;
+    clearStorage(): void;
+    clearLocalStorage(): void;
+    clearCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}

package/lib/core/auth/models/auth-result.model.d.ts

@@ -0,0 +1,4 @@
+export declare class AuthResult {
+    access_token: string;
+    refresh_token: string;
+}

package/lib/core/auth/models/federated-login-request.model.d.ts

@@ -0,0 +1,5 @@
+export declare class FederatedLoginRequest {
+    accessToken: string;
+    rememberMe?: boolean;
+    license?: string;
+}

package/lib/core/auth/models/login-request.model.d.ts

@@ -0,0 +1,6 @@
+export declare class LoginRequest {
+    username: string;
+    password: string;
+    rememberMe?: boolean;
+    license?: string;
+}

package/lib/core/auth/storage.service.d.ts

@@ -0,0 +1,21 @@
+import { CoreConfigService } from '../services/core-config.service';
+import * as i0 from "@angular/core";
+export declare class StorageService {
+    private coreConfig;
+    get storageKey(): string;
+    get secretKey(): string;
+    private storage;
+    constructor(coreConfig: CoreConfigService);
+    setRememberMe(rememberMe: boolean): void;
+    set(key: string, value: any): void;
+    get(key: string): any;
+    /**
+     * Check if storage is valid (can be decrypted) without side effects
+     */
+    isValid(): boolean;
+    clear(): void;
+    private encrypt;
+    private decrypt;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
+}

package/lib/core/directives/draggable/draggable-dialog.directive.d.ts

@@ -0,0 +1,23 @@
+import { ElementRef, OnInit, Renderer2, OnChanges, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DraggableDialogDirective implements OnInit, OnChanges {
+    private el;
+    private renderer;
+    private isDragging;
+    private startX;
+    private startY;
+    private offsetX;
+    private offsetY;
+    dragHandleSelector: string | undefined;
+    enableDrag: boolean;
+    private dragHandle;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateDragState;
+    onMouseDown(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DraggableDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DraggableDialogDirective, "[draggableDialog]", never, { "dragHandleSelector": { "alias": "dragHandle"; "required": false; }; "enableDrag": { "alias": "enableDrag"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/core/directives/fullscreen/fullscreen.directive.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FullscreenDirective {
+    private el;
+    private renderer;
+    private isFullScreen;
+    private preFullscreenState;
+    fullscreenTarget: string;
+    constructor(el: ElementRef, renderer: Renderer2);
+    toggle(): void;
+    getFullscreenState(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FullscreenDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FullscreenDirective, "[appFullscreen]", never, { "fullscreenTarget": { "alias": "fullscreenTarget"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/core/directives/resizable/resizable-dialog.directive.d.ts

@@ -0,0 +1,30 @@
+import { ElementRef, Renderer2, OnInit, OnDestroy, OnChanges, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ResizableDialogDirective implements OnInit, OnDestroy, OnChanges {
+    private el;
+    private renderer;
+    private resizeHandles;
+    private activeHandle;
+    private startX;
+    private startY;
+    private startWidth;
+    private startHeight;
+    private startLeft;
+    private startTop;
+    enableResize: boolean;
+    private directions;
+    constructor(el: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateResizeState;
+    ngOnDestroy(): void;
+    private setStyle;
+    private createResizeHandles;
+    private removeResizeHandles;
+    onMouseDown(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(): void;
+    private getComputedStyleValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizableDialogDirective, "[resizableDialog]", never, { "enableResize": { "alias": "enableResize"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/core/environments/environment.d.ts

@@ -0,0 +1,7 @@
+export declare const environment: {
+    config: string;
+    production: boolean;
+    apiBaseUrl: string;
+    loginEndpoint: string;
+    apiSegment: string;
+};

package/lib/core/environments/environment.prod.d.ts

@@ -0,0 +1,7 @@
+export declare const environment: {
+    config: string;
+    production: boolean;
+    apiBaseUrl: string;
+    loginEndpoint: string;
+    apiSegment: string;
+};

package/lib/core/helpers/crypto-helper.service.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+export declare class CryptoHelperService {
+    private encoder;
+    private decoder;
+    private secretKey;
+    setSecretKey(key: string): void;
+    private getKey;
+    encrypt(value: string): Promise<string | null>;
+    decrypt(value: string): Promise<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CryptoHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CryptoHelperService>;
+}

package/lib/core/http/http-stream.service.d.ts

@@ -0,0 +1,18 @@
+import { NgZone } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { StorageService } from '../auth/storage.service';
+import { ChatStreamResponse } from '../../app/chat/model/chat-stream-response.model';
+import * as i0 from "@angular/core";
+export declare class HttpStreamService {
+    private ngZone;
+    private tokenStorage;
+    private http;
+    constructor(ngZone: NgZone, tokenStorage: StorageService, http: HttpClient);
+    /**
+     * Creates a POST-based HTTP streaming connection using fetch()
+     */
+    createHttpStream(url: string, body: any, headers?: Record<string, string>): Observable<ChatStreamResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpStreamService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpStreamService>;
+}

package/lib/core/http/http.service.d.ts

@@ -0,0 +1,20 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { CoreConfigService } from '../services/core-config.service';
+import { StorageService } from '../auth/storage.service';
+import * as i0 from "@angular/core";
+export declare class HttpService {
+    private http;
+    private tokenStorage;
+    private coreConfig;
+    get apiUrl(): string;
+    constructor(http: HttpClient, tokenStorage: StorageService, coreConfig: CoreConfigService);
+    get(url: string, param?: object, nestedParam?: boolean, showLoader?: boolean, refresh?: boolean, headers?: HttpHeaders): Observable<any>;
+    private buildHttpParams;
+    post(url: string, param?: object, showLoader?: boolean, headers?: HttpHeaders): Observable<any>;
+    patch(url: string, param?: object, showLoader?: boolean, headers?: HttpHeaders): Observable<any>;
+    delete(url: string, param?: object, showLoader?: boolean, headers?: HttpHeaders): Observable<any>;
+    private returnResponse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpService>;
+}