@burtson-labs/bandit-engine 2.0.8

package/dist/index.d.ts

@@ -0,0 +1,1636 @@
+import React, { ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as zustand from 'zustand';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions } from '@tanstack/react-query';
+import { Observable } from 'rxjs';
+import { AlertColor } from '@mui/material';
+
+/**
+ * Common types used across all AI providers
+ */
+interface AIMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+interface AIChatRequest {
+    model: string;
+    messages: AIMessage[];
+    stream?: boolean;
+    temperature?: number;
+    maxTokens?: number;
+    images?: string[];
+    options?: Record<string, unknown>;
+}
+interface AIChatResponse {
+    message: {
+        content: string;
+        role: 'assistant';
+    };
+    done?: boolean;
+}
+interface AIGenerateRequest {
+    model: string;
+    prompt: string;
+    stream?: boolean;
+    options?: Record<string, unknown>;
+}
+interface AIGenerateResponse {
+    response: string;
+    done?: boolean;
+}
+interface AIModel {
+    name: string;
+    size?: number;
+    details?: {
+        format?: string;
+        family?: string;
+        families?: string[];
+        parameter_size?: string;
+        quantization_level?: string;
+    };
+    digest?: string;
+    modified_at?: string;
+}
+interface AIProviderConfig {
+    type: 'ollama' | 'openai' | 'azure-openai' | 'anthropic' | 'gateway';
+    baseUrl?: string;
+    apiKey?: string;
+    apiVersion?: string;
+    deploymentName?: string;
+    gatewayUrl?: string;
+    provider?: 'openai' | 'azure-openai' | 'anthropic' | 'ollama';
+    tokenFactory?: () => string | null;
+}
+
+/**
+ * Subscription tiers available in the system
+ */
+type SubscriptionTier = 'basic' | 'premium' | 'pro' | 'team' | 'trial' | 'expired';
+/**
+ * Available feature keys that can be toggled
+ */
+type FeatureKey = 'memory' | 'documentKnowledge' | 'moodAdaptation' | 'chatSuggestions' | 'tts' | 'stt' | 'adminDashboardEnabled' | 'limitedAdminDashboard' | 'semanticSearchSimple' | 'semanticSearchPremium' | 'advancedSearch' | 'advancedMemories';
+/**
+ * Feature matrix defining which features are enabled/disabled
+ */
+type FeatureMatrix = Partial<Record<FeatureKey, boolean>>;
+/**
+ * Feature flag configuration interface
+ */
+interface FeatureFlagConfig {
+    /** Current subscription tier - if not provided, assumes OSS mode */
+    subscriptionType?: SubscriptionTier;
+    /** JWT claim key to extract roles from (default: 'roles') */
+    rolesClaimKey?: string;
+    /** JWT claim key to extract subscription type from (default: 'subscriptionType') */
+    subscriptionTypeClaimKey?: string;
+    /** JWT claim key to check if subscription is active (default: 'isSubscribed') */
+    isSubscribedClaimKey?: string;
+    /** LocalStorage key where JWT is stored (default: 'bandit-jwt') */
+    jwtStorageKey?: string;
+    /** Manual feature overrides - takes precedence in OSS mode */
+    featureMatrix?: FeatureMatrix;
+    /** Admin role name that grants full access (default: 'admin') */
+    adminRole?: string;
+    /** Enable debug logging for feature evaluation */
+    debug?: boolean;
+}
+/**
+ * Default feature matrices for each subscription tier
+ */
+declare const DEFAULT_TIER_FEATURES: Record<SubscriptionTier, FeatureMatrix>;
+/**
+ * Open source mode - all features available by default
+ */
+declare const OSS_DEFAULT_FEATURES: FeatureMatrix;
+/**
+ * Trial usage information from JWT
+ */
+interface TrialUsage {
+    chatRequestsUsed: number;
+    chatRequestsLimit: number;
+    generateRequestsUsed: number;
+    generateRequestsLimit: number;
+}
+/**
+ * Feature evaluation result
+ */
+interface FeatureEvaluation {
+    /** Current subscription tier (or 'oss' for open source mode) */
+    tier: SubscriptionTier | 'oss';
+    /** Whether the user has admin role */
+    isAdmin: boolean;
+    /** Whether the user's subscription is active (false for trial users) */
+    isSubscribed: boolean;
+    /** Trial usage limits (only present for trial users) */
+    trialUsage?: TrialUsage;
+    /** Final computed feature matrix */
+    features: FeatureMatrix;
+    /** Evaluation metadata */
+    metadata: {
+        jwtFound: boolean;
+        jwtValid: boolean;
+        rolesExtracted: string[];
+        subscriptionTypeFromJWT?: SubscriptionTier;
+        isSubscribedFromJWT?: boolean;
+        trialUsageFromJWT?: TrialUsage;
+        evaluatedAt: number;
+    };
+}
+
+interface PackageSettings {
+    ollamaUrl?: string;
+    defaultModel: string;
+    fallbackModel?: string;
+    aiProvider?: AIProviderConfig;
+    gatewayApiUrl: string;
+    s3ApiUrl?: string;
+    brandingConfigUrl: string;
+    homeUrl?: string | null;
+    feedbackEmail?: string;
+    featureFlags?: FeatureFlagConfig;
+}
+
+interface ChatConfig {
+    packageSettings: PackageSettings;
+    /** Feature flag configuration - can override packageSettings.featureFlags */
+    featureFlags?: FeatureFlagConfig;
+    children?: React.ReactNode;
+}
+declare const ChatProvider: React.FC<ChatConfig>;
+
+declare const Chat: () => react_jsx_runtime.JSX.Element | null;
+
+declare const Management: () => react_jsx_runtime.JSX.Element | null;
+
+declare const ChatModal: React.FC<{
+    open: boolean;
+    onClose: () => void;
+}>;
+
+declare function defineCustomElement<Props extends Record<string, unknown>>(name: string, Component: React.ComponentType<Props>): void;
+
+/**
+ * 🔍 Bandit Debug Logger Service
+ *
+ * Centralized logging service that provides environment-aware debug logging.
+ *
+ * Features:
+ * - Production builds: Only errors and info logs are shown
+ * - Development mode: All logs are shown with clear debug prefixes
+ * - Consistent formatting for debugging purposes
+ * - Clear indication that logs are for debugging
+ *
+ * Usage:
+ * ```typescript
+ * import { debugLogger } from './services/logging/debugLogger';
+ *
+ * debugLogger.debug('LLM processing', { prompt, response });
+ * debugLogger.info('User action completed', { action });
+ * debugLogger.warn('Performance warning', { timing });
+ * debugLogger.error('Operation failed', { error });
+ * ```
+ */
+type LogContext = unknown;
+declare class DebugLogger {
+    private isDevelopment;
+    constructor();
+    private detectDevelopmentMode;
+    /**
+     * Set development mode manually (useful for testing or runtime configuration)
+     */
+    setDevelopmentMode(isDev: boolean): void;
+    /**
+     * Debug logs - only shown in development mode
+     * These are obfuscated/hidden in production builds
+     * DISABLED to prevent console flooding during chat processing
+     */
+    debug(message: string, context?: LogContext): void;
+    /**
+     * Info logs - shown in both development and production
+     * Used for important user-facing information
+     */
+    info(message: string, context?: LogContext): void;
+    /**
+     * Warning logs - shown in both development and production
+     * Used for non-critical issues that should be noted
+     */
+    warn(message: string, context?: LogContext): void;
+    /**
+     * Error logs - always shown in both development and production
+     * Used for critical errors that need attention
+     */
+    error(message: string, context?: LogContext): void;
+    /**
+     * LLM-specific debug logging for RAG and AI features
+     * DISABLED to prevent console flooding during chat processing
+     */
+    llmDebug(operation: string, data: LogContext): void;
+    /**
+     * RAG-specific debug logging for knowledge and document processing
+     * DISABLED to prevent console flooding during chat processing
+     */
+    ragDebug(operation: string, data: LogContext): void;
+    /**
+     * Memory-specific debug logging for AI memory features
+     * DISABLED to prevent console flooding during chat processing
+     */
+    memoryDebug(operation: string, data: LogContext): void;
+    /**
+     * Table logging for development debugging
+     * DISABLED to prevent console flooding during chat processing
+     */
+    table(data: unknown[], message?: string): void;
+}
+declare const debugLogger: DebugLogger;
+
+interface JwtClaims {
+    /**
+     * The unique identifier for the user.
+     */
+    sub: string;
+    /**
+     * The email address of the user.
+     * This is typically used for authentication and user identification.
+     */
+    email: string;
+    /**
+     * Optional display name for the user if provided by the identity provider.
+     */
+    name?: string;
+    /**
+     * Optional preferred username provided by the identity provider.
+     */
+    preferred_username?: string;
+    /**
+     * Optional direct URL to a profile image for the user.
+     */
+    picture?: string;
+    /**
+     * Optional given name of the user when available.
+     */
+    given_name?: string;
+    /**
+     * Optional family name of the user when available.
+     */
+    family_name?: string;
+    /**
+     * The roles assigned to the user.
+     * 'user' | 'admin' | 'super-admin'
+     */
+    roles: string[];
+    /**
+     * The time at which the token was issued.
+     * This is represented as a Unix timestamp (seconds since the epoch).
+     */
+    iat: number;
+    /**
+     * The time at which the token will expire.
+     * This is represented as a Unix timestamp (seconds since the epoch).
+     */
+    exp: number;
+    /**
+     * The issuer of the token.
+     * This is typically the URL of the authentication server.
+     *
+     */
+    iss: string;
+    /**
+     * Optional team session identifier for team features.
+     * Present when user belongs to a team.
+     */
+    teamSid?: string;
+    /**
+     * Optional team identifier for team features.
+     * Present when user belongs to a team.
+     */
+    teamId?: string;
+}
+declare class AuthenticationService {
+    getToken(): string | null;
+    setToken(token: string): void;
+    clearToken(): void;
+    isAuthenticated(): boolean;
+    isTokenExpired(token: string): boolean;
+    parseJwtClaims(token: string): JwtClaims | null;
+}
+declare const authenticationService: AuthenticationService;
+
+/**
+ * Context value interface
+ */
+interface FeatureFlagContextValue {
+    /** Check if a specific feature is enabled */
+    hasFeature: (feature: FeatureKey) => boolean;
+    /** Get the current feature evaluation */
+    getEvaluation: () => FeatureEvaluation | null;
+    /** Refresh feature evaluation (useful after login/logout) */
+    refreshEvaluation: () => void;
+    /** Check if user is admin */
+    isAdmin: () => boolean;
+    /** Get current tier */
+    getCurrentTier: () => SubscriptionTier | 'oss';
+    /** Update subscription tier dynamically */
+    updateTier: (tier: SubscriptionTier) => void;
+    /** Check if we're in OSS mode */
+    isOSSMode: () => boolean;
+}
+declare const FeatureFlagContext: React.Context<FeatureFlagContextValue | undefined>;
+/**
+ * Props for the FeatureFlagProvider
+ */
+interface FeatureFlagProviderProps {
+    config: FeatureFlagConfig;
+    children: React.ReactNode;
+}
+/**
+ * Feature Flag Provider Component
+ */
+declare const FeatureFlagProvider: React.FC<FeatureFlagProviderProps>;
+/**
+ * Hook to use feature flags
+ */
+declare const useFeatureFlag: () => FeatureFlagContextValue;
+
+/**
+ * Convenience hook that provides an easier API for feature checking
+ */
+declare const useFeatures: () => {
+    hasFeature: () => boolean;
+    hasMemory: () => boolean;
+    hasDocumentKnowledge: () => boolean;
+    hasMoodAdaptation: () => boolean;
+    hasChatSuggestions: () => boolean;
+    hasTTS: () => boolean;
+    hasSTT: () => boolean;
+    hasAdminDashboard: () => boolean;
+    hasLimitedAdminDashboard: () => boolean;
+    hasSimpleSearch: () => boolean;
+    hasPremiumSearch: () => boolean;
+    hasAdvancedSearch: () => boolean;
+    hasAdvancedMemories: () => boolean;
+    isAdmin: () => boolean;
+    getCurrentTier: () => "oss";
+    isOSSMode: () => boolean;
+    isSubscribed: () => boolean;
+    isPremiumTier: () => boolean;
+    isProTier: () => boolean;
+    isTrialTier: () => boolean;
+    isTeamTier: () => boolean;
+    isExpiredTier: () => boolean;
+    needsUpgrade: () => boolean;
+    getTrialUsage: () => undefined;
+    isTrialLimitReached: () => boolean;
+    getTrialRemainingRequests: () => null;
+    updateTier: () => undefined;
+    refreshFeatures: () => undefined;
+    getFullEvaluation: () => null;
+} | {
+    hasFeature: (feature: FeatureKey) => boolean;
+    hasMemory: () => boolean;
+    hasDocumentKnowledge: () => boolean;
+    hasMoodAdaptation: () => boolean;
+    hasChatSuggestions: () => boolean;
+    hasTTS: () => boolean;
+    hasSTT: () => boolean;
+    hasAdminDashboard: () => boolean;
+    hasLimitedAdminDashboard: () => boolean;
+    hasSimpleSearch: () => boolean;
+    hasPremiumSearch: () => boolean;
+    hasAdvancedSearch: () => boolean;
+    hasAdvancedMemories: () => boolean;
+    isAdmin: () => boolean;
+    getCurrentTier: () => SubscriptionTier | "oss";
+    isOSSMode: () => boolean;
+    isSubscribed: () => boolean;
+    isPremiumTier: () => boolean;
+    isProTier: () => boolean;
+    isTrialTier: () => boolean;
+    isTeamTier: () => boolean;
+    isExpiredTier: () => boolean;
+    needsUpgrade: (feature: FeatureKey, requiredTier?: SubscriptionTier) => false | SubscriptionTier;
+    getTrialUsage: () => TrialUsage | undefined;
+    isTrialLimitReached: (type: "chat" | "generate") => boolean;
+    getTrialRemainingRequests: (type: "chat" | "generate") => number | null;
+    updateTier: (tier: SubscriptionTier) => void;
+    refreshFeatures: () => void;
+    getFullEvaluation: () => FeatureEvaluation | null;
+};
+/**
+ * Hook specifically for checking if features should be shown in UI
+ */
+declare const useFeatureVisibility: () => {
+    showMemoryToggle: () => boolean;
+    showDocumentUpload: () => boolean;
+    showMoodSettings: () => boolean;
+    showSuggestions: () => boolean;
+    showVoiceControls: () => boolean;
+    showAdminPanel: () => boolean;
+    showLimitedAdminPanel: () => boolean;
+    showAdvancedSearch: () => boolean;
+    shouldShowUpgradePrompt: (feature: FeatureKey) => boolean;
+    getUpgradeMessage: (feature: FeatureKey) => string | null;
+};
+
+/**
+ * Service for managing subscription tiers and feature flags
+ */
+declare class FeatureFlagService {
+    private static instance;
+    private subscribers;
+    static getInstance(): FeatureFlagService;
+    /**
+     * Subscribe to subscription tier changes
+     */
+    subscribe(callback: () => void): () => void;
+    /**
+     * Notify all subscribers of changes
+     */
+    private notifySubscribers;
+    /**
+     * Update subscription tier and notify components
+     */
+    updateSubscriptionTier(tier: SubscriptionTier): void;
+    /**
+     * Sync subscription with external service
+     */
+    syncWithExternalService(userId: string, apiUrl?: string): Promise<SubscriptionTier>;
+    /**
+     * Get features available for a specific tier
+     */
+    getFeaturesForTier(tier: SubscriptionTier): Partial<Record<FeatureKey, boolean>>;
+    /**
+     * Check if a tier includes a specific feature
+     */
+    tierHasFeature(tier: SubscriptionTier, feature: FeatureKey): boolean;
+    /**
+     * Get the minimum tier required for a feature
+     */
+    getMinimumTierForFeature(feature: FeatureKey): SubscriptionTier | null;
+    /**
+     * Compare tier levels
+     */
+    compareTiers(tier1: SubscriptionTier, tier2: SubscriptionTier): number;
+    /**
+     * Check if tier1 is higher than or equal to tier2
+     */
+    tierMeetsRequirement(userTier: SubscriptionTier, requiredTier: SubscriptionTier): boolean;
+    /**
+     * Get upgrade path from current tier to target tier
+     */
+    getUpgradePath(currentTier: SubscriptionTier, targetTier: SubscriptionTier): SubscriptionTier[];
+    /**
+     * Handle subscription upgrade/downgrade
+     */
+    handleSubscriptionChange(newTier: SubscriptionTier, options?: {
+        apiUrl?: string;
+        userId?: string;
+        notifyExternal?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Preview features for a potential upgrade
+     */
+    previewUpgrade(targetTier: SubscriptionTier): {
+        tier: SubscriptionTier;
+        newFeatures: FeatureKey[];
+        allFeatures: Partial<Record<FeatureKey, boolean>>;
+    };
+    /**
+     * Generate feature comparison matrix
+     */
+    generateFeatureMatrix(): Record<SubscriptionTier, Partial<Record<FeatureKey, boolean>>>;
+}
+/**
+ * Singleton instance
+ */
+declare const featureFlagService: FeatureFlagService;
+/**
+ * Convenience functions for external use
+ */
+declare const updateSubscriptionTier: (tier: SubscriptionTier) => void;
+declare const syncSubscriptionWithAPI: (userId: string, apiUrl?: string) => Promise<SubscriptionTier>;
+declare const handleSubscriptionUpgrade: (newTier: SubscriptionTier, options?: Parameters<typeof featureFlagService.handleSubscriptionChange>[1]) => Promise<boolean>;
+declare const previewTierUpgrade: (tier: SubscriptionTier) => {
+    tier: SubscriptionTier;
+    newFeatures: FeatureKey[];
+    allFeatures: Partial<Record<FeatureKey, boolean>>;
+};
+declare const getFeatureMatrix: () => Record<SubscriptionTier, Partial<Record<FeatureKey, boolean>>>;
+
+/**
+ * Hook to initialize and manage voice models from the gateway API
+ * Automatically loads voices when gateway API URL is available
+ */
+declare const useVoices: () => {
+    availableVoices: string[];
+    selectedVoice: string;
+    defaultVoice: string;
+    fallbackVoice: string;
+    isLoading: boolean;
+    isServiceAvailable: boolean;
+    setSelectedVoice: (voice: string) => void;
+    refreshVoices: () => Promise<void>;
+    hasVoices: boolean;
+    isVoiceServiceConfigured: boolean;
+};
+
+interface VoiceState {
+    availableVoices: string[];
+    selectedVoice: string;
+    defaultVoice: string;
+    fallbackVoice: string;
+    isLoading: boolean;
+    isServiceAvailable: boolean;
+    initialized: boolean;
+    setSelectedVoice: (voice: string) => void;
+    loadVoicesFromAPI: () => Promise<void>;
+    refreshVoices: () => Promise<void>;
+    forceInitialize: () => Promise<void>;
+}
+declare const useVoiceStore: zustand.UseBoundStore<zustand.StoreApi<VoiceState>>;
+
+interface VoiceModelsResponse {
+    models: string[];
+    defaultModel: string;
+    fallbackModel: string;
+}
+declare class VoiceService {
+    private static instance;
+    private cachedModels;
+    private cacheTimestamp;
+    private readonly CACHE_DURATION;
+    private constructor();
+    static getInstance(): VoiceService;
+    private getGatewayApiUrl;
+    private isValid;
+    private isCacheValid;
+    fetchAvailableVoices(): Promise<VoiceModelsResponse>;
+    clearCache(): void;
+}
+declare const voiceService: VoiceService;
+
+interface GatewayMessageContent {
+    type: 'text' | 'image_url';
+    text?: string;
+    image_url?: {
+        url: string;
+        detail?: 'low' | 'high' | 'auto';
+    };
+}
+interface GatewayMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string | GatewayMessageContent[];
+    name?: string;
+    images?: string[];
+}
+interface GatewayChatRequest {
+    model: string;
+    messages: GatewayMessage[];
+    stream?: boolean;
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    provider?: 'openai' | 'azure-openai' | 'anthropic' | 'ollama';
+    stop?: string | string[];
+    images?: string[];
+}
+interface GatewayChatResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        delta?: {
+            role?: string;
+            content?: string;
+        };
+        message?: {
+            role: string;
+            content: string;
+        };
+        finish_reason?: string | null;
+    }[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+interface GatewayGenerateRequest {
+    model: string;
+    prompt: string;
+    stream?: boolean;
+    temperature?: number;
+    max_tokens?: number;
+    provider?: 'openai' | 'azure-openai' | 'anthropic' | 'ollama';
+    stop?: string | string[];
+}
+interface GatewayGenerateResponse {
+    model: string;
+    created_at: string;
+    response: string;
+    done: boolean;
+    context?: number[];
+    total_duration?: number;
+    load_duration?: number;
+    prompt_eval_count?: number;
+    prompt_eval_duration?: number;
+    eval_count?: number;
+    eval_duration?: number;
+}
+interface GatewayModel {
+    id: string;
+    name: string;
+    provider: string;
+    created: number;
+    modified_at: string;
+    size: number;
+    digest: string;
+    details?: {
+        format: string;
+        family: string;
+        families: string[];
+        parameter_size: string;
+        quantization_level: string;
+    };
+}
+interface GatewayModelsResponse {
+    models: GatewayModel[];
+}
+interface GatewayHealthResponse {
+    status: 'healthy' | 'unhealthy';
+    version: string;
+    providers: {
+        name: string;
+        status: 'available' | 'unavailable';
+        models_count: number;
+    }[];
+    uptime: number;
+}
+interface GatewayMemoryRecord {
+    id: string;
+    type: string;
+    content: string;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown>;
+}
+interface GatewayMemoryResponse {
+    records: GatewayMemoryRecord[];
+    total: number;
+    nextCursor?: string | null;
+}
+
+type GatewayQueryOptions<TData> = Omit<UseQueryOptions<TData, Error>, "queryKey" | "queryFn">;
+declare const useGatewayHealth: (options?: GatewayQueryOptions<GatewayHealthResponse>) => _tanstack_react_query.UseQueryResult<GatewayHealthResponse, Error>;
+declare const useGatewayModels: (options?: GatewayQueryOptions<GatewayModel[]>) => _tanstack_react_query.UseQueryResult<GatewayModel[], Error>;
+declare const useGatewayMemory: (options?: GatewayQueryOptions<GatewayMemoryResponse>) => _tanstack_react_query.UseQueryResult<GatewayMemoryResponse, Error>;
+
+declare enum TTSState {
+    IDLE = "IDLE",
+    LOADING = "LOADING",
+    PLAYING = "PLAYING",
+    PAUSED = "PAUSED",
+    ERROR = "ERROR"
+}
+interface TTSProgress {
+    currentTime: number;
+    duration: number;
+    percentage: number;
+    buffered: number;
+    state: TTSState;
+}
+interface TTSOptions {
+    useStreaming?: boolean;
+    useRealtime?: boolean;
+    onStateChange?: (state: TTSState) => void;
+    onProgress?: (progress: TTSProgress) => void;
+}
+/**
+ * Streaming TTS client with playback controls
+ */
+declare class StreamingTTSClient {
+    private static instance;
+    private audio;
+    private objectUrl;
+    private controller;
+    private audioHandlers;
+    private stateSubject;
+    private progressSubject;
+    private constructor();
+    static getInstance(): StreamingTTSClient;
+    /**
+     * Get current state
+     */
+    getCurrentState(): TTSState;
+    /**
+     * Get state changes as observable
+     */
+    getStateChanges(): Observable<TTSState>;
+    /**
+     * Get progress updates as observable
+     */
+    getProgress(): Observable<TTSProgress>;
+    /**
+     * Speak text with simple streaming
+     */
+    speakStream(text: string, voice: string, options?: TTSOptions): Observable<void>;
+    /**
+   * Simple streaming implementation - no queues, just direct playback
+   */
+    private performSimpleStreaming;
+    /**
+   * Set up audio event listeners
+   */
+    private setupAudioListeners;
+    /**
+     * Stop playback
+     */
+    stop(): void;
+    /**
+     * Pause playback
+     */
+    pause(): void;
+    /**
+     * Resume playback
+     */
+    resume(): void;
+    /**
+     * Set state and notify observers
+     */
+    private setState;
+    /**
+     * Reset the TTS client completely - useful for model changes
+     */
+    reset(): void;
+    /**
+     * Clear only the audio event handlers
+     */
+    private clearAudioHandlers;
+    /**
+     * Clean up resources
+     */
+    private cleanup;
+}
+declare const getStreamingTTSClient: () => StreamingTTSClient;
+declare const speakStream: (text: string, voice: string, options?: TTSOptions) => Observable<void>;
+declare const stopTTS: () => void;
+declare const pauseTTS: () => void;
+declare const resumeTTS: () => void;
+declare const getTTSState: () => TTSState;
+
+interface UseTTSReturn {
+    isPlaying: boolean;
+    isPaused: boolean;
+    isLoading: boolean;
+    error: string | null;
+    progress: TTSProgress | null;
+    state: TTSState;
+    speak: (text: string, options?: TTSOptions) => Promise<void>;
+    stop: () => void;
+    pause: () => void;
+    resume: () => void;
+    forcePlay: () => Promise<void>;
+    isAvailable: boolean;
+    currentVoice: string;
+}
+/**
+ * React hook for TTS with streaming support and playback controls
+ */
+declare const useTTS: () => UseTTSReturn;
+/**
+ * Global TTS controls hook - useful for global stop functionality
+ */
+declare const useGlobalTTS: () => {
+    stopAll: () => void;
+};
+
+interface SubscriptionExpiredModalProps {
+    open: boolean;
+    onNavigateHome?: () => void;
+    onManageSubscription?: () => void;
+    onClose?: () => void;
+    userEmail?: string;
+}
+/**
+ * Modal shown when user has an expired subscription
+ * Provides options to navigate home or manage subscription
+ */
+declare const SubscriptionExpiredModal: React.FC<SubscriptionExpiredModalProps>;
+
+interface SubscriptionExpiredGuardProps {
+    children: React.ReactNode;
+    onNavigateHome?: () => void;
+    onManageSubscription?: () => void;
+    userEmail?: string;
+    /** If true, allows closing the modal and continues with limited access */
+    allowContinue?: boolean;
+}
+/**
+ * Guard component that shows subscription expired modal for expired users
+ * Wraps children and shows modal when subscription is expired
+ */
+declare const SubscriptionExpiredGuard: React.FC<SubscriptionExpiredGuardProps>;
+
+interface FeedbackButtonProps {
+    /** Whether the parent component is in fullscreen mode */
+    fullScreen?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Z-index override */
+    zIndex?: number;
+    /** Custom feedback email (overrides package settings) */
+    feedbackEmail?: string;
+    /** Show as inline button instead of floating */
+    inline?: boolean;
+    /** Custom button text for inline mode */
+    buttonText?: string;
+    /** Custom size */
+    size?: 'small' | 'medium' | 'large';
+    /** Custom positioning */
+    position?: {
+        bottom?: number | string;
+        right?: number | string;
+        top?: number | string;
+        left?: number | string;
+    };
+    /** Use absolute positioning instead of fixed (for modal contexts) */
+    absolute?: boolean;
+}
+declare const FeedbackButton: React.FC<FeedbackButtonProps>;
+
+interface FeedbackModalProps {
+    open: boolean;
+    onClose: () => void;
+    feedbackEmail?: string;
+}
+declare const FeedbackModal: React.FC<FeedbackModalProps>;
+
+interface FeedbackRequest {
+    title: string;
+    description: string;
+    category: 'bug' | 'feature' | 'improvement' | 'question' | 'other';
+    priority: 'low' | 'medium' | 'high' | 'critical';
+    annoyanceLevel?: number;
+    images?: string[];
+    userAgent?: string;
+    browserInfo?: {
+        name: string;
+        version: string;
+        platform: string;
+    };
+    sessionInfo?: {
+        currentModel?: string;
+        currentProvider?: string;
+        conversationId?: string;
+        timestamp: string;
+    };
+    contactEmail?: string;
+    attachments?: {
+        name: string;
+        content: string;
+        type: string;
+        size: number;
+    }[];
+}
+interface FeedbackResponse {
+    id: string;
+    status: 'submitted' | 'acknowledged' | 'in-progress' | 'resolved' | 'rejected';
+    message: string;
+    ticketNumber?: string;
+    estimatedResponse?: string;
+    mailtoUrl?: string;
+}
+interface FeedbackCategories {
+    bug: {
+        label: 'Bug Report';
+        description: 'Something isn\'t working as expected';
+        icon: 'BugReport';
+        color: '#f44336';
+    };
+    feature: {
+        label: 'Feature Request';
+        description: 'Suggest a new feature or enhancement';
+        icon: 'Lightbulb';
+        color: '#2196f3';
+    };
+    improvement: {
+        label: 'Improvement';
+        description: 'Suggest improvements to existing features';
+        icon: 'TrendingUp';
+        color: '#ff9800';
+    };
+    question: {
+        label: 'Question';
+        description: 'Ask a question about usage or functionality';
+        icon: 'Help';
+        color: '#9c27b0';
+    };
+    other: {
+        label: 'Other';
+        description: 'General feedback or other topics';
+        icon: 'Message';
+        color: '#607d8b';
+    };
+}
+interface FeedbackPriorities {
+    low: {
+        label: 'Low';
+        description: 'Minor issue, can wait';
+        color: '#4caf50';
+    };
+    medium: {
+        label: 'Medium';
+        description: 'Normal priority';
+        color: '#ff9800';
+    };
+    high: {
+        label: 'High';
+        description: 'Important, needs attention soon';
+        color: '#f44336';
+    };
+    critical: {
+        label: 'Critical';
+        description: 'Urgent, blocks usage';
+        color: '#d32f2f';
+    };
+}
+
+interface NotificationConfig {
+    message: string;
+    severity?: AlertColor;
+    duration?: number;
+    anchorOrigin?: {
+        vertical: 'top' | 'bottom';
+        horizontal: 'left' | 'center' | 'right';
+    };
+}
+interface NotificationContextType {
+    showNotification: (config: NotificationConfig | string) => void;
+    showError: (message: string) => void;
+    showSuccess: (message: string) => void;
+    showWarning: (message: string) => void;
+    showInfo: (message: string) => void;
+}
+declare const useNotification: () => NotificationContextType;
+interface NotificationProviderProps {
+    children: ReactNode;
+    defaultDuration?: number;
+    defaultPosition?: {
+        vertical: 'top' | 'bottom';
+        horizontal: 'left' | 'center' | 'right';
+    };
+}
+declare const NotificationProvider: React.FC<NotificationProviderProps>;
+
+/**
+ * Global notification handler that can be used throughout the application
+ */
+declare class NotificationService {
+    private notificationContext;
+    /**
+     * Set the notification context (usually called from a component that has access to useNotification)
+     */
+    setContext(context: NotificationContextType): void;
+    /**
+     * Show a generic notification
+     */
+    show(message: string, severity?: 'success' | 'error' | 'warning' | 'info'): void;
+    /**
+     * Show an error notification
+     */
+    showError(message: string): void;
+    /**
+     * Show a success notification
+     */
+    showSuccess(message: string): void;
+    /**
+     * Show a warning notification
+     */
+    showWarning(message: string): void;
+    /**
+     * Show an info notification
+     */
+    showInfo(message: string): void;
+    /**
+     * Handle HTTP errors and show appropriate notifications
+     */
+    handleHttpError(error: unknown, customMessage?: string): void;
+    /**
+     * Handle network/connection errors
+     */
+    handleNetworkError(error: unknown, customMessage?: string): void;
+    /**
+     * Handle validation errors
+     */
+    handleValidationError(errors: readonly string[] | string, customMessage?: string): void;
+}
+declare const notificationService: NotificationService;
+
+/**
+ * Hook to initialize and use the notification service
+ * This should be called once near the root of your component tree
+ */
+declare const useNotificationService: () => {
+    handleHttpError: (error: unknown, customMessage?: string) => void;
+    handleNetworkError: (error: unknown, customMessage?: string) => void;
+    handleValidationError: (errors: readonly string[] | string, customMessage?: string) => void;
+    showNotification: (config: NotificationConfig | string) => void;
+    showError: (message: string) => void;
+    showSuccess: (message: string) => void;
+    showWarning: (message: string) => void;
+    showInfo: (message: string) => void;
+};
+
+/**
+ * Enhanced HTTP error handler that provides user-friendly notifications
+ */
+declare const handleHttpError: (error: unknown, context?: string) => {
+    status: number;
+    message: string;
+    code: string | undefined;
+    handled: boolean;
+} | {
+    status: number;
+    message: string;
+    handled: boolean;
+    code?: undefined;
+};
+/**
+ * Handle validation errors from API responses
+ */
+declare const handleValidationError: (errors: unknown, context?: string) => void;
+/**
+ * Success notification helper
+ */
+declare const showSuccessNotification: (message: string, context?: string) => void;
+/**
+ * Info notification helper
+ */
+declare const showInfoNotification: (message: string, context?: string) => void;
+
+declare function validateSystemIntegrity(): boolean;
+declare function initializeCoreSystem(): string;
+
+declare const SYSTEM_FLAGS: {
+    readonly LICENSED_MODE: true;
+    readonly VALIDATION_ENABLED: true;
+    readonly BURTSON_VERIFIED: true;
+    readonly LICENSE_CHECK: "© 2025 Burtson Labs";
+};
+declare function getSystemConstants(): {
+    version: string;
+    hash: string;
+    validation: string;
+    flags: {
+        readonly LICENSED_MODE: true;
+        readonly VALIDATION_ENABLED: true;
+        readonly BURTSON_VERIFIED: true;
+        readonly LICENSE_CHECK: "© 2025 Burtson Labs";
+    };
+    license: string;
+};
+
+declare function validateEnvironment(): boolean;
+declare function getCriticalConfig(): {
+    systemId: string;
+    validation: string;
+    required: boolean;
+    timestamp: string;
+};
+
+interface VectorMemory {
+    id: string;
+    content: string;
+    title?: string;
+    tags?: string[];
+    score?: number;
+    uploadedBy: string;
+    uploadedAt: string;
+    source?: 'auto' | 'user';
+    pinned?: boolean;
+    lastReferencedAt?: string;
+    metadata?: VectorMemoryMetadata;
+}
+interface VectorMemoryMetadata {
+    personalConfidence?: number;
+    topic?: string;
+    engagement?: number;
+    extractedFrom?: string;
+    tags?: string[];
+    additionalProperties?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface VectorDocument {
+    id: string;
+    filename: string;
+    content: string;
+    mimeType: string;
+    score?: number;
+    uploadedBy: string;
+    uploadedAt: string;
+    isUserContent: boolean;
+    isTeamContent: boolean;
+    contentSource: 'user' | 'team';
+}
+interface SearchResult {
+    memories: VectorMemory[];
+    documents: VectorDocument[];
+    success: boolean;
+    message?: string;
+}
+type RawFileRecord = Record<string, unknown>;
+interface MemorySearchFilters {
+    includePinned?: boolean;
+    topics?: string[];
+    source?: Array<'auto' | 'user'>;
+    tags?: string[];
+}
+interface CreateMemoryOptions {
+    title?: string;
+    tags?: string[];
+    source?: 'auto' | 'user';
+    pinned?: boolean;
+    metadata?: VectorMemoryMetadata;
+    lastReferencedAt?: string;
+}
+interface FileUploadResult {
+    success: boolean;
+    fileId: string;
+    message?: string;
+}
+/**
+ * Upload request structure that matches the backend C# UploadRequest class
+ */
+interface UploadRequest {
+    /** The file to upload */
+    file: File;
+    /**
+     * Indicates whether the file should be shared with the team.
+     * If true and the user has team information, the file will be saved to the team bucket.
+     * If false, the file will be saved to the user's personal bucket regardless of team membership.
+     * Defaults to true for backward compatibility.
+     */
+    shareWithTeam: boolean;
+}
+/**
+ * Vector Database Service for Advanced Semantic Search
+ *
+ * This service handles storage and retrieval of memories and documents
+ * in the vector database when advanced semantic search is enabled.
+ *
+ * Feature Gating:
+ * - Requires admin authorization, pro subscription, or team subscription
+ * - Supports admin users and pro/team subscription tiers
+ * - Only active when advancedMemories feature is enabled
+ */
+declare class VectorDatabaseService {
+    private baseUrl;
+    private s3ApiUrl;
+    private token;
+    private lastAvailabilityState;
+    private lastConfigState;
+    constructor(gatewayApiUrl?: string, s3ApiUrl?: string);
+    /**
+     * Set authentication token for API calls
+     */
+    setAuthToken(token: string): void;
+    /**
+     * Get authorization headers
+     */
+    private getHeaders;
+    /**
+     * Check if vector database is available and configured
+     */
+    isAvailable(): boolean;
+    /**
+     * Create and embed a memory in the vector database
+     */
+    createMemory(content: string, options?: CreateMemoryOptions): Promise<{
+        success: boolean;
+        memoryId?: string;
+        message?: string;
+    }>;
+    /**
+     * Search memories in the vector database
+     */
+    private coerceStringArray;
+    private coerceString;
+    private coerceBoolean;
+    private coerceNumber;
+    private asRecord;
+    private toRecordArray;
+    private buildMetadata;
+    private normalizeMemoryResult;
+    /**
+     * Search memories in the vector database
+     */
+    searchMemories(query: string, limit?: number, scoreThreshold?: number, filters?: MemorySearchFilters): Promise<VectorMemory[]>;
+    /**
+     * Get user's memories with pagination
+     */
+    getMyMemories(skip?: number, limit?: number): Promise<VectorMemory[]>;
+    /**
+     * Delete a memory from the vector database
+     */
+    deleteMemory(memoryId: string): Promise<boolean>;
+    /**
+     * Update a memory in the vector database (e.g., pin/unpin)
+     */
+    updateMemory(memoryId: string, updates: {
+        pinned?: boolean;
+        content?: string;
+        title?: string;
+        tags?: string[];
+    }): Promise<boolean>;
+    /**
+     * Batch create memories in the vector database
+     */
+    batchCreateMemories(memories: Array<{
+        content: string;
+        title?: string;
+        tags?: string[];
+    }>, mode?: 'append' | 'replace' | 'smartDedupe', clearExisting?: boolean): Promise<{
+        success: boolean;
+        message: string;
+        results: Array<{
+            content: string;
+            success: boolean;
+            memoryId?: string;
+            mongoId?: string;
+            contentLength?: number;
+            message: string;
+            action: string;
+        }>;
+        summary: {
+            mode: string;
+            totalProcessed: number;
+            successCount: number;
+            failureCount: number;
+            skippedCount: number;
+            clearedExistingCount: number;
+            clearedExisting: boolean;
+        };
+    }>;
+    /**
+     * Advanced batch create memories with chunking and progress reporting
+     */
+    batchCreateMemoriesAdvanced(memories: Array<{
+        content: string;
+        title?: string;
+        tags?: string[];
+    }>, options?: {
+        mode?: 'append' | 'replace' | 'smartDedupe';
+        clearExisting?: boolean;
+        chunkSize?: number;
+        onProgress?: (current: number, total: number, message: string) => void;
+        validateContent?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        totalMemories: number;
+        successCount: number;
+        failureCount: number;
+        skippedCount: number;
+        errors: string[];
+        warnings: string[];
+        chunks: number;
+        duration: number;
+    }>;
+    /**
+     * Upload file to S3 API and get file ID
+     *
+     * @param file - The file to upload
+     * @param shareWithTeam - Whether to share the file with team members.
+     *                       If true and user has team info, file goes to team bucket.
+     *                       If false, file goes to user's personal bucket.
+     *                       Defaults to true for backward compatibility.
+     * @returns Promise<FileUploadResult> with success status and file ID
+     */
+    uploadFile(file: File, shareWithTeam?: boolean): Promise<FileUploadResult>;
+    /**
+     * Embed a document in the vector database via Gateway API
+     */
+    embedDocument(fileId: string, shareWithTeam?: boolean): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Search documents in the vector database
+     */
+    searchDocuments(query: string, limit?: number, scoreThreshold?: number): Promise<VectorDocument[]>;
+    /**
+     * Get available files that haven't been embedded
+     */
+    getAvailableFiles(skip?: number, limit?: number): Promise<RawFileRecord[]>;
+    /**
+     * Get user's files - tries both Gateway API and S3 API
+     */
+    getUserFiles(skip?: number, limit?: number): Promise<RawFileRecord[]>;
+    /**
+     * Get user's files from S3 API as fallback
+     */
+    private getUserFilesFromS3;
+    /**
+     * Download a file using MongoDB ObjectId (secure method)
+     */
+    downloadFile(fileId: string, filename: string): Promise<void>;
+    /**
+     * Get file blob using MongoDB ObjectId (for displaying content in modal)
+     */
+    getFileBlob(fileId: string): Promise<Blob>;
+    /**
+     * Get file content for preview using MongoDB ObjectId (from Gateway API metadata)
+     */
+    getFilePreview(fileId: string, maxSize?: number): Promise<{
+        content: string;
+        mimeType: string;
+    } | null>;
+    /**
+     * Delete a document from vector database
+     */
+    deleteDocument(fileId: string): Promise<boolean>;
+    /**
+     * Search both memories and documents simultaneously
+     */
+    searchAll(query: string, memoryLimit?: number, documentLimit?: number, scoreThreshold?: number): Promise<SearchResult>;
+    /**
+     * Configure the service with API URLs
+     * This should be called by the main application with environment variables
+     */
+    configure(gatewayApiUrl: string, s3ApiUrl: string): void;
+    /**
+     * Manual debug function to test Gateway API connection
+     * Call this from browser console to debug API issues
+     */
+    debugTestConnection(): Promise<void>;
+    /**
+     * Test embedding a specific file ID that you know exists
+     */
+    debugTestEmbedding(fileId: string): Promise<void>;
+}
+declare const vectorDatabaseService: VectorDatabaseService;
+
+interface MigrationStatus {
+    success: boolean;
+    migratedMemories: number;
+    migratedDocuments: number;
+    errors: string[];
+    warnings: string[];
+    totalTime: number;
+}
+interface MigrationProgress {
+    phase: 'memories' | 'documents' | 'cleanup' | 'complete';
+    current: number;
+    total: number;
+    currentItem?: string;
+    errors: string[];
+}
+/**
+ * Vector Database Migration Service
+ *
+ * Handles migration of memories and documents from IndexedDB to vector database
+ * when advanced semantic search is enabled for the first time.
+ *
+ * Features:
+ * - Batch migration to avoid overwhelming the API
+ * - Progress tracking with user feedback
+ * - Error handling and retry logic
+ * - Cleanup of migrated IndexedDB data (optional)
+ * - Rollback capability in case of issues
+ */
+declare class VectorMigrationService {
+    private static readonly BATCH_SIZE;
+    private static readonly RETRY_DELAY;
+    private static readonly MAX_RETRIES;
+    private migrationKey;
+    private progressCallbacks;
+    /**
+     * Check if migration has already been completed
+     */
+    isMigrationCompleted(): boolean;
+    /**
+     * Mark migration as completed
+     */
+    markMigrationCompleted(): void;
+    /**
+     * Reset migration status (for testing or re-migration)
+     */
+    resetMigrationStatus(): void;
+    /**
+     * Add progress callback for UI updates
+     */
+    onProgress(callback: (progress: MigrationProgress) => void): void;
+    /**
+     * Remove progress callback
+     */
+    removeProgressCallback(callback: (progress: MigrationProgress) => void): void;
+    /**
+     * Notify progress callbacks
+     */
+    private notifyProgress;
+    /**
+     * Sleep utility for rate limiting
+     */
+    private sleep;
+    /**
+     * Get all memories directly from IndexedDB
+     */
+    private getAllMemories;
+    /**
+     * Get all knowledge documents directly from IndexedDB
+     */
+    private getAllDocuments;
+    /**
+     * Clear all memories from IndexedDB
+     */
+    private clearAllMemories;
+    /**
+     * Clear all documents from IndexedDB
+     */
+    private clearAllDocuments;
+    /**
+     * Migrate memories from IndexedDB to vector database
+     */
+    private migrateMemories;
+    /**
+     * Migrate documents from IndexedDB to vector database
+     */
+    private migrateDocuments;
+    /**
+     * Perform full migration from IndexedDB to vector database
+     */
+    performMigration(options?: {
+        cleanupAfterMigration?: boolean;
+        skipIfCompleted?: boolean;
+    }): Promise<MigrationStatus>;
+    /**
+     * Clean up local IndexedDB data after successful migration
+     */
+    private cleanupLocalData;
+    /**
+     * Estimate migration time and data size
+     */
+    estimateMigration(): Promise<{
+        memoryCount: number;
+        documentCount: number;
+        estimatedTime: number;
+        estimatedDataSize: number;
+    }>;
+}
+declare const vectorMigrationService: VectorMigrationService;
+
+interface VectorStoreStatus {
+    isEnabled: boolean;
+    isAvailable: boolean;
+    isMigrating: boolean;
+    migrationRequired: boolean;
+    migrationProgress?: MigrationProgress;
+    lastError?: string;
+}
+interface SearchOptions {
+    memoryLimit?: number;
+    documentLimit?: number;
+    scoreThreshold?: number;
+    useVector?: boolean;
+    filters?: MemorySearchFilters;
+}
+/**
+ * Advanced Vector Storage Hook
+ *
+ * Manages the transition between IndexedDB and Vector Database storage
+ * when advanced semantic search is enabled. Handles feature gating,
+ * migration, and unified API for both storage backends.
+ *
+ * Features:
+ * - Automatic migration when advanced search is first enabled
+ * - Unified API that works with both IndexedDB and Vector DB
+ * - Feature gating based on subscription tier and admin claims
+ * - Progress tracking for migration operations
+ * - Fallback to IndexedDB if vector service unavailable
+ */
+declare const useVectorStore: () => {
+    status: VectorStoreStatus;
+    isVectorEnabled: boolean;
+    refreshCompatibilityCheck: () => void;
+    performMigration: (options?: {
+        cleanupAfterMigration?: boolean;
+    }) => Promise<MigrationStatus>;
+    getMigrationEstimate: () => Promise<{
+        memoryCount: number;
+        documentCount: number;
+        estimatedTime: number;
+        estimatedDataSize: number;
+    }>;
+    addMemory: (content: string, tags?: string[], source?: "auto" | "user", options?: {
+        metadata?: VectorMemoryMetadata;
+        pinned?: boolean;
+        title?: string;
+        lastReferencedAt?: string;
+    }) => Promise<{
+        success: boolean;
+        id?: string;
+        error?: string;
+    }>;
+    batchCreateMemories: (memories: Array<{
+        content: string;
+        title?: string;
+        tags?: string[];
+    }>, mode?: "append" | "replace" | "smartDedupe", clearExisting?: boolean) => Promise<{
+        success: boolean;
+        message: string;
+        results: Array<{
+            content: string;
+            success: boolean;
+            memoryId?: string;
+            mongoId?: string;
+            contentLength?: number;
+            message: string;
+            action: string;
+        }>;
+        summary: {
+            mode: string;
+            totalProcessed: number;
+            successCount: number;
+            failureCount: number;
+            skippedCount: number;
+            clearedExistingCount: number;
+            clearedExisting: boolean;
+        };
+    }>;
+    batchCreateMemoriesAdvanced: (memories: Array<{
+        content: string;
+        title?: string;
+        tags?: string[];
+    }>, options?: {
+        mode?: "append" | "replace" | "smartDedupe";
+        clearExisting?: boolean;
+        chunkSize?: number;
+        onProgress?: (current: number, total: number, message: string) => void;
+        validateContent?: boolean;
+    }) => Promise<{
+        success: boolean;
+        message: string;
+        totalMemories: number;
+        successCount: number;
+        failureCount: number;
+        skippedCount: number;
+        errors: string[];
+        warnings: string[];
+        chunks: number;
+        duration: number;
+    }>;
+    batchImportMemories: (fromIndexedDB?: boolean, mode?: "append" | "replace" | "smartDedupe") => Promise<{
+        success: boolean;
+        message: string;
+        migratedCount: number;
+        totalMemories: number;
+        errors: string[];
+    }>;
+    searchMemories: (query: string, options?: SearchOptions) => Promise<VectorMemory[]>;
+    getUserMemories: (skip?: number, limit?: number) => Promise<VectorMemory[]>;
+    deleteMemory: (memoryId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    updateMemory: (memoryId: string, updates: {
+        pinned?: boolean;
+        content?: string;
+        title?: string;
+        tags?: string[];
+    }) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    uploadDocument: (file: File, shareWithTeam?: boolean) => Promise<{
+        success: boolean;
+        fileId?: string;
+        error?: string;
+    }>;
+    searchDocuments: (query: string, options?: SearchOptions) => Promise<VectorDocument[]>;
+    getUserDocuments: (skip?: number, limit?: number) => Promise<VectorDocument[]>;
+    deleteDocument: (fileId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    downloadVectorFile: (fileId: string, filename: string) => Promise<void>;
+    getFilePreview: (fileId: string) => Promise<{
+        content: string;
+        mimeType: string;
+    } | null>;
+    getFileBlob: (fileId: string) => Promise<Blob>;
+    searchAll: (query: string, options?: SearchOptions) => Promise<SearchResult>;
+    initializeVectorService: () => Promise<void>;
+};
+
+interface GatewayContract {
+    chat(request: GatewayChatRequest): Promise<GatewayChatResponse>;
+    generate(request: GatewayGenerateRequest): Promise<GatewayGenerateResponse>;
+    health(): Promise<GatewayHealthResponse>;
+}
+
+export { type AIChatRequest, type AIChatResponse, type AIGenerateRequest, type AIGenerateResponse, type AIMessage, type AIModel, type AIProviderConfig, Chat, type ChatConfig, ChatModal, ChatProvider, type CreateMemoryOptions, DEFAULT_TIER_FEATURES, DebugLogger, type FeatureEvaluation, type FeatureFlagConfig, FeatureFlagContext, type FeatureFlagContextValue, FeatureFlagProvider, type FeatureFlagProviderProps, FeatureFlagService, type FeatureKey, type FeatureMatrix, FeedbackButton, type FeedbackButtonProps, type FeedbackCategories, FeedbackModal, type FeedbackModalProps, type FeedbackPriorities, type FeedbackRequest, type FeedbackResponse, type FileUploadResult, type GatewayChatRequest, type GatewayChatResponse, type GatewayContract, type GatewayGenerateRequest, type GatewayGenerateResponse, type GatewayHealthResponse, type GatewayMemoryRecord, type GatewayMemoryResponse, type GatewayMessage, type GatewayMessageContent, type GatewayModel, type GatewayModelsResponse, type GatewayQueryOptions, type LogContext, Management, type MemorySearchFilters, type MigrationProgress, type MigrationStatus, type NotificationConfig, type NotificationContextType, NotificationProvider, type NotificationProviderProps, NotificationService, OSS_DEFAULT_FEATURES, type PackageSettings, SYSTEM_FLAGS, type SearchOptions, type SearchResult, StreamingTTSClient, SubscriptionExpiredGuard, type SubscriptionExpiredGuardProps, SubscriptionExpiredModal, type SubscriptionExpiredModalProps, type SubscriptionTier, type TTSOptions, type TTSProgress, TTSState, type TrialUsage, type UploadRequest, type UseTTSReturn, VectorDatabaseService, type VectorDocument, type VectorMemory, type VectorMemoryMetadata, VectorMigrationService, type VectorStoreStatus, type VoiceModelsResponse, VoiceService, type VoiceState, authenticationService, debugLogger, defineCustomElement, featureFlagService, getCriticalConfig, getFeatureMatrix, getStreamingTTSClient, getSystemConstants, getTTSState, handleHttpError, handleSubscriptionUpgrade, handleValidationError, initializeCoreSystem, notificationService, pauseTTS, previewTierUpgrade, resumeTTS, showInfoNotification, showSuccessNotification, speakStream as speakWithStreaming, stopTTS, syncSubscriptionWithAPI, updateSubscriptionTier, useFeatureFlag, useFeatureVisibility, useFeatures, useGatewayHealth, useGatewayMemory, useGatewayModels, useGlobalTTS, useNotification, useNotificationService, useTTS, useVectorStore, useVoiceStore, useVoices, validateEnvironment, validateSystemIntegrity, vectorDatabaseService, vectorMigrationService, voiceService };