@jaak.ai/stamps 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/types/components/my-component/my-component.d.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from '../../stencil-public-runtime';
+import { CameraInfoResponse, CapturedImagesResponse, StatusResponse } from '../../types/component-types';
 export declare class JaakStamps {
     el: HTMLElement;
     debug: boolean;
@@ -6,94 +7,87 @@ export declare class JaakStamps {
     maskSize: number;
     cropMargin: number;
     useDocumentClassification: boolean;
+    preferredCamera: 'auto' | 'front' | 'back';
+    captureDelay: number;
     captureCompleted: EventEmitter<any>;
     isReady: EventEmitter<boolean>;
-    isVideoActive: boolean;
-    statusMessage: string;
-    statusColor: string;
-    bestScore: number;
-    capturedFullFrame: string | null;
-    capturedCroppedId: string | null;
-    capturedBackFullFrame: string | null;
-    capturedBackCroppedId: string | null;
-    captureStep: 'front' | 'back' | 'completed';
-    isCapturing: boolean;
-    showFlipAnimation: boolean;
-    showSuccessAnimation: boolean;
-    shouldMirrorVideo: boolean;
+    detectionBoxes: Array<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        score: number;
+    }>;
     sideAlignment: {
         top: boolean;
         right: boolean;
         bottom: boolean;
         left: boolean;
     };
-    isDetectionPaused: boolean;
-    isLoading: boolean;
-    isModelPreloaded: boolean;
     isMaskReady: boolean;
+    shouldMirrorVideo: boolean;
+    showCameraSelector: boolean;
+    isSwitchingCamera: boolean;
+    hasDocumentDetected: boolean;
+    currentStatus: {
+        message: string;
+        description?: string;
+        type: 'initializing' | 'ready' | 'loading' | 'active' | 'error';
+        isInitialized: boolean;
+    };
+    performanceData: {
+        fps: number;
+        inferenceTime: number;
+        memoryUsage: number;
+        onnxLoadTime: number;
+        frameProcessingTime: number;
+        totalDetections: number;
+        successfulDetections: number;
+        detectionRate: number;
+    };
+    private serviceContainer;
+    private logger;
+    private eventBus;
+    private stateManager;
+    private cameraService;
+    private detectionService;
     private videoRef?;
-    private canvasRef?;
-    private session?;
-    private startTime?;
+    private detectionContainer?;
     private videoStream?;
     private animationId?;
-    private hasScreenshotTaken;
     private lastDetectedBox?;
-    private mobileNetSession?;
-    private mobileNetClassMap?;
+    private startTime?;
+    private hasScreenshotTaken;
+    private alignmentStartTime?;
+    private alignmentTimer?;
+    private performanceMetrics;
+    private performanceUpdateInterval?;
     private frameSkipCounter;
     private readonly FRAME_SKIP;
     private consecutiveFailures;
     private readonly MAX_FAILURES;
     private lastInferenceTime;
     private readonly MIN_INFERENCE_INTERVAL;
-    private preprocessCanvas?;
-    private preprocessCtx?;
-    private captureCanvas?;
-    private captureCtx?;
-    private readonly MODEL_PATH;
-    private readonly MOBILENET_MODEL_PATH;
-    private readonly MOBILENET_CLASSES_PATH;
-    private readonly INPUT_SIZE;
-    private readonly CONFIDENCE_THRESHOLD;
-    private readonly ID1_ASPECT_RATIO;
-    private debugLog;
-    private validateMaskSize;
-    private validateCropMargin;
-    private emitReadyEvent;
-    private isRearCamera;
     componentDidLoad(): Promise<void>;
-    private setupResizeObserver;
+    private initializeServices;
+    private setupEventListeners;
+    private initializeComponent;
+    private validateProps;
+    private loadOnnxRuntime;
+    private finalizeInitialization;
+    private updateStatus;
+    private emitReadyEvent;
+    private handleStateChange;
+    private initializeResizeObserver;
     private handleResize;
     private updateMaskDimensions;
-    private initializeCanvasPool;
-    disconnectedCallback(): void;
-    getCapturedImages(): Promise<{
-        front: {
-            fullFrame: string;
-            cropped: string;
-        };
-        back: {
-            fullFrame: string;
-            cropped: string;
-        };
-        metadata: {
-            hasBackCapture: boolean;
-            totalImages: number;
-        };
-    }>;
+    getCapturedImages(): Promise<CapturedImagesResponse>;
     isProcessCompleted(): Promise<boolean>;
     startCapture(): Promise<void>;
     stopCapture(): Promise<void>;
     resetCapture(): Promise<void>;
-    getStatus(): Promise<{
-        isVideoActive: boolean;
-        captureStep: "front" | "back" | "completed";
-        statusMessage: string;
-        hasImages: boolean;
-        isProcessCompleted: boolean;
-        isModelPreloaded: boolean;
-    }>;
+    skipBackCapture(): Promise<void>;
+    getStatus(): Promise<StatusResponse>;
     preloadModel(): Promise<{
         success: boolean;
         message: string;
@@ -103,29 +97,46 @@ export declare class JaakStamps {
         error: any;
         message?: undefined;
     }>;
-    skipBackCapture(): Promise<void>;
-    private loadMobileNetModel;
-    private preprocessMobileNet;
-    private classifyDocument;
-    private cleanup;
-    private cleanupCanvasPool;
-    private getMaxResolution;
-    private setupCamera;
-    private preprocess;
-    private getSessionOptions;
+    getCameraInfo(): Promise<CameraInfoResponse>;
+    setPreferredCamera(camera: 'auto' | 'front' | 'back'): Promise<{
+        success: boolean;
+        selectedCamera: string;
+        availableCameras: number;
+    }>;
+    setCaptureDelay(delay: number): Promise<{
+        success: boolean;
+        captureDelay: number;
+    }>;
+    getCaptureDelay(): Promise<number>;
+    setTorchEnabled(enabled: boolean): Promise<{
+        success: boolean;
+        enabled: boolean;
+    }>;
+    focusAtPoint(x: number, y: number): Promise<{
+        success: boolean;
+        coordinates: {
+            x: number;
+            y: number;
+        };
+    }>;
     private startDetection;
+    private initializeVideoStream;
     private detectFrame;
-    private isCardInFrame;
-    private checkSideAlignment;
-    private areAllSidesAligned;
+    disconnectedCallback(): void;
+    private cleanup;
+    render(): any;
+    private updateDetectionBoxes;
     private updateMaskColor;
-    private updateGuidanceStatus;
-    private drawDetections;
     private takeScreenshot;
     private triggerCaptureAnimation;
+    private completeProcess;
     private stopDetection;
+    private toggleCameraSelector;
+    private handleCameraSwitch;
     private resetDetection;
-    private completeProcess;
     private exitSession;
-    render(): any;
+    private initializePerformanceMonitor;
+    private updatePerformanceMetrics;
+    private recordOnnxPerformance;
+    private recordFrameProcessing;
 }

package/dist/types/components.d.ts

@@ -5,29 +5,45 @@
  * It contains typing information for all components that exist in this project.
  */
 import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
+import { CameraInfoResponse, CapturedImagesResponse, StatusResponse } from "./types/component-types";
+export { CameraInfoResponse, CapturedImagesResponse, StatusResponse } from "./types/component-types";
 export namespace Components {
     interface JaakStamps {
         /**
-          * @default 10
+          * @default 15
          */
         "alignmentTolerance": number;
         /**
-          * @default 0
+          * @default 1500
+         */
+        "captureDelay": number;
+        /**
+          * @default 20
          */
         "cropMargin": number;
         /**
           * @default false
          */
         "debug": boolean;
-        "getCapturedImages": () => Promise<{ front: { fullFrame: string; cropped: string; }; back: { fullFrame: string; cropped: string; }; metadata: { hasBackCapture: boolean; totalImages: number; }; }>;
-        "getStatus": () => Promise<{ isVideoActive: boolean; captureStep: "front" | "back" | "completed"; statusMessage: string; hasImages: boolean; isProcessCompleted: boolean; isModelPreloaded: boolean; }>;
+        "focusAtPoint": (x: number, y: number) => Promise<{ success: boolean; coordinates: { x: number; y: number; }; }>;
+        "getCameraInfo": () => Promise<CameraInfoResponse>;
+        "getCaptureDelay": () => Promise<number>;
+        "getCapturedImages": () => Promise<CapturedImagesResponse>;
+        "getStatus": () => Promise<StatusResponse>;
         "isProcessCompleted": () => Promise<boolean>;
         /**
-          * @default 90
+          * @default 80
          */
         "maskSize": number;
+        /**
+          * @default 'auto'
+         */
+        "preferredCamera": 'auto' | 'front' | 'back';
         "preloadModel": () => Promise<{ success: boolean; message: string; error?: undefined; } | { success: boolean; error: any; message?: undefined; }>;
         "resetCapture": () => Promise<void>;
+        "setCaptureDelay": (delay: number) => Promise<{ success: boolean; captureDelay: number; }>;
+        "setPreferredCamera": (camera: "auto" | "front" | "back") => Promise<{ success: boolean; selectedCamera: string; availableCameras: number; }>;
+        "setTorchEnabled": (enabled: boolean) => Promise<{ success: boolean; enabled: boolean; }>;
         "skipBackCapture": () => Promise<void>;
         "startCapture": () => Promise<void>;
         "stopCapture": () => Promise<void>;
@@ -67,11 +83,15 @@ declare global {
 declare namespace LocalJSX {
     interface JaakStamps {
         /**
-          * @default 10
+          * @default 15
          */
         "alignmentTolerance"?: number;
         /**
-          * @default 0
+          * @default 1500
+         */
+        "captureDelay"?: number;
+        /**
+          * @default 20
          */
         "cropMargin"?: number;
         /**
@@ -79,11 +99,15 @@ declare namespace LocalJSX {
          */
         "debug"?: boolean;
         /**
-          * @default 90
+          * @default 80
          */
         "maskSize"?: number;
         "onCaptureCompleted"?: (event: JaakStampsCustomEvent<any>) => void;
         "onIsReady"?: (event: JaakStampsCustomEvent<boolean>) => void;
+        /**
+          * @default 'auto'
+         */
+        "preferredCamera"?: 'auto' | 'front' | 'back';
         /**
           * @default false
          */

package/dist/types/services/CameraService.d.ts

@@ -0,0 +1,46 @@
+import { ICameraService, CameraInfo } from './interfaces/ICameraService';
+import { ILogger } from './interfaces/ILogger';
+import { IEventBus } from './interfaces/IEventBus';
+export declare class CameraService implements ICameraService {
+    private logger;
+    private eventBus;
+    private availableCameras;
+    private selectedCameraId;
+    private deviceType;
+    private preferredCameraFacing;
+    private preferredCamera;
+    constructor(logger: ILogger, eventBus: IEventBus, preferredCamera?: 'auto' | 'front' | 'back');
+    detectDeviceType(): Promise<'mobile' | 'desktop' | 'tablet'>;
+    enumerateDevices(): Promise<MediaDeviceInfo[]>;
+    getAvailableCameras(): MediaDeviceInfo[];
+    isMultipleCamerasAvailable(): boolean;
+    getSelectedCameraId(): string | null;
+    setSelectedCamera(cameraId: string): Promise<void>;
+    getPreferredFacing(): 'environment' | 'user' | null;
+    setupCamera(constraints?: MediaTrackConstraints): Promise<MediaStream>;
+    switchCamera(cameraId: string): Promise<void>;
+    flipToNextCamera(): Promise<void>;
+    savePreference(): void;
+    loadPreference(): void;
+    isRearCamera(stream: MediaStream): boolean;
+    getCameraInfo(): {
+        availableCameras: CameraInfo[];
+        selectedCameraId: string | null;
+        deviceType: string;
+        isMultipleCamerasAvailable: boolean;
+        preferredFacing: 'environment' | 'user' | null;
+    };
+    private checkCameraPermission;
+    private handleCameraPermissionError;
+    private setInitialCameraPreference;
+    private selectFrontCamera;
+    private selectBackCamera;
+    private selectAutoCamera;
+    private updatePreferredFacing;
+    private getMaxResolution;
+    private applyAdvancedCameraSettings;
+    private applyBasicFocusSettings;
+    private getCapabilitiesSummary;
+    setTorchEnabled(enabled: boolean, stream?: MediaStream): Promise<boolean>;
+    focusAtPoint(x: number, y: number, stream?: MediaStream): Promise<boolean>;
+}

package/dist/types/services/DetectionService.d.ts

@@ -0,0 +1,35 @@
+import { IDetectionService, DetectionBox, SideAlignment, ClassificationResult } from './interfaces/IDetectionService';
+import { ILogger } from './interfaces/ILogger';
+export declare class DetectionService implements IDetectionService {
+    private logger;
+    private debug;
+    private useDocumentClassification;
+    private session?;
+    private mobileNetSession?;
+    private mobileNetClassMap?;
+    private modelLoaded;
+    private deviceStrategy;
+    private readonly MODEL_PATH;
+    private readonly MOBILENET_MODEL_PATH;
+    private readonly MOBILENET_CLASSES_PATH;
+    private readonly INPUT_SIZE;
+    private readonly CONFIDENCE_THRESHOLD;
+    private preprocessCanvas?;
+    private preprocessCtx?;
+    private captureCanvas?;
+    constructor(logger: ILogger, debug?: boolean, useDocumentClassification?: boolean);
+    loadModel(): Promise<void>;
+    loadClassificationModel(): Promise<void>;
+    isModelLoaded(): boolean;
+    preprocess(video: HTMLVideoElement): any;
+    runInference(inputTensor: any): Promise<DetectionBox[]>;
+    classifyDocument(canvas: HTMLCanvasElement): Promise<ClassificationResult | null>;
+    checkSideAlignment(box: DetectionBox, maskConfig: any): SideAlignment;
+    isCardInFrame(box: DetectionBox): boolean;
+    areAllSidesAligned(alignment: SideAlignment): boolean;
+    cleanup(): void;
+    private initializeCanvasPool;
+    private cleanupCanvasPool;
+    private float32ToFloat16;
+    private preprocessMobileNet;
+}

package/dist/types/services/EventBusService.d.ts

@@ -0,0 +1,9 @@
+import { IEventBus, EventCallback } from './interfaces/IEventBus';
+export declare class EventBusService implements IEventBus {
+    private events;
+    on<T = any>(event: string, callback: EventCallback<T>): void;
+    off(event: string, callback: EventCallback): void;
+    emit<T = any>(event: string, data?: T): void;
+    once<T = any>(event: string, callback: EventCallback<T>): void;
+    clear(): void;
+}

package/dist/types/services/LoggerService.d.ts

@@ -0,0 +1,12 @@
+import { ILogger } from './interfaces/ILogger';
+export declare class LoggerService implements ILogger {
+    private debugMode;
+    constructor(debug?: boolean);
+    setDebugMode(debug: boolean): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    debug(...args: any[]): void;
+    state(state: string, data?: any): void;
+    performance(operation: string, duration: number): void;
+}

package/dist/types/services/ServiceContainer.d.ts

@@ -0,0 +1,27 @@
+import { ILogger } from './interfaces/ILogger';
+import { ICameraService } from './interfaces/ICameraService';
+import { IDetectionService } from './interfaces/IDetectionService';
+import { IStateManager } from './interfaces/IStateManager';
+import { IEventBus } from './interfaces/IEventBus';
+export interface ComponentConfig {
+    debug: boolean;
+    alignmentTolerance: number;
+    maskSize: number;
+    cropMargin: number;
+    useDocumentClassification: boolean;
+    preferredCamera: 'auto' | 'front' | 'back';
+    captureDelay: number;
+}
+export declare class ServiceContainer {
+    private services;
+    constructor(config: ComponentConfig);
+    private initializeServices;
+    get<T>(serviceName: string): T;
+    getLogger(): ILogger;
+    getEventBus(): IEventBus;
+    getStateManager(): IStateManager;
+    getCameraService(): ICameraService;
+    getDetectionService(): IDetectionService;
+    updateConfig(config: Partial<ComponentConfig>): void;
+    cleanup(): void;
+}

package/dist/types/services/StateManagerService.d.ts

@@ -0,0 +1,15 @@
+import { IStateManager, CaptureState, CapturedImages } from './interfaces/IStateManager';
+import { IEventBus } from './interfaces/IEventBus';
+export declare class StateManagerService implements IStateManager {
+    private eventBus;
+    private captureState;
+    private capturedImages;
+    constructor(eventBus: IEventBus);
+    getCaptureState(): CaptureState;
+    updateCaptureState(updates: Partial<CaptureState>): void;
+    getCapturedImages(): CapturedImages;
+    setCapturedImages(images: Partial<CapturedImages>): void;
+    reset(): void;
+    isProcessCompleted(): boolean;
+    canProceedToBack(): boolean;
+}

package/dist/types/services/factories/DeviceStrategyFactory.d.ts

@@ -0,0 +1,4 @@
+import { IDeviceStrategy } from '../strategies/IDeviceStrategy';
+export declare class DeviceStrategyFactory {
+    static createStrategy(): IDeviceStrategy;
+}

package/dist/types/services/interfaces/ICameraService.d.ts

@@ -0,0 +1,34 @@
+export interface CameraInfo {
+    id: string;
+    label: string;
+    selected: boolean;
+}
+export interface CameraPreference {
+    cameraId: string;
+    facing: 'environment' | 'user' | null;
+    timestamp: number;
+}
+export interface ICameraService {
+    detectDeviceType(): Promise<'mobile' | 'desktop' | 'tablet'>;
+    enumerateDevices(): Promise<MediaDeviceInfo[]>;
+    getAvailableCameras(): MediaDeviceInfo[];
+    isMultipleCamerasAvailable(): boolean;
+    getSelectedCameraId(): string | null;
+    setSelectedCamera(cameraId: string): Promise<void>;
+    getPreferredFacing(): 'environment' | 'user' | null;
+    setupCamera(constraints?: MediaTrackConstraints): Promise<MediaStream>;
+    switchCamera(cameraId: string): Promise<void>;
+    flipToNextCamera(): Promise<void>;
+    savePreference(): void;
+    loadPreference(): void;
+    isRearCamera(stream: MediaStream): boolean;
+    setTorchEnabled(enabled: boolean, stream?: MediaStream): Promise<boolean>;
+    focusAtPoint(x: number, y: number, stream?: MediaStream): Promise<boolean>;
+    getCameraInfo(): {
+        availableCameras: CameraInfo[];
+        selectedCameraId: string | null;
+        deviceType: string;
+        isMultipleCamerasAvailable: boolean;
+        preferredFacing: 'environment' | 'user' | null;
+    };
+}

package/dist/types/services/interfaces/IDetectionService.d.ts

@@ -0,0 +1,31 @@
+export interface DetectionBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    score: number;
+    classId?: number;
+}
+export interface SideAlignment {
+    top: boolean;
+    right: boolean;
+    bottom: boolean;
+    left: boolean;
+}
+export interface ClassificationResult {
+    class: string;
+    confidence: number;
+    classIndex: number;
+}
+export interface IDetectionService {
+    loadModel(): Promise<void>;
+    loadClassificationModel(): Promise<void>;
+    isModelLoaded(): boolean;
+    preprocess(video: HTMLVideoElement): any;
+    runInference(inputTensor: any): Promise<DetectionBox[]>;
+    classifyDocument(canvas: HTMLCanvasElement): Promise<ClassificationResult | null>;
+    checkSideAlignment(box: DetectionBox, maskConfig: any): SideAlignment;
+    isCardInFrame(box: DetectionBox): boolean;
+    areAllSidesAligned(alignment: SideAlignment): boolean;
+    cleanup(): void;
+}

package/dist/types/services/interfaces/IEventBus.d.ts

@@ -0,0 +1,16 @@
+export type EventCallback<T = any> = (data: T) => void;
+export interface IEventBus {
+    on<T = any>(event: string, callback: EventCallback<T>): void;
+    off(event: string, callback: EventCallback): void;
+    emit<T = any>(event: string, data?: T): void;
+    once<T = any>(event: string, callback: EventCallback<T>): void;
+    clear(): void;
+}
+export interface ComponentEvents {
+    'capture-completed': any;
+    'ready': boolean;
+    'camera-changed': string;
+    'detection-updated': any[];
+    'state-changed': any;
+    'error': Error;
+}

package/dist/types/services/interfaces/ILogger.d.ts

@@ -0,0 +1,8 @@
+export interface ILogger {
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    debug(...args: any[]): void;
+    state(state: string, data?: any): void;
+    performance(operation: string, duration: number): void;
+}

package/dist/types/services/interfaces/IStateManager.d.ts

@@ -0,0 +1,35 @@
+export interface CaptureState {
+    step: 'front' | 'back' | 'completed';
+    isCapturing: boolean;
+    isDetectionPaused: boolean;
+    isVideoActive: boolean;
+    isLoading: boolean;
+    showFlipAnimation: boolean;
+    showSuccessAnimation: boolean;
+    bestScore: number;
+    hasScreenshotTaken: boolean;
+}
+export interface CapturedImages {
+    front: {
+        fullFrame: string | null;
+        cropped: string | null;
+    };
+    back: {
+        fullFrame: string | null;
+        cropped: string | null;
+    };
+    metadata: {
+        totalImages: number;
+        processCompleted: boolean;
+        backCaptureSkipped: boolean;
+    };
+}
+export interface IStateManager {
+    getCaptureState(): CaptureState;
+    updateCaptureState(updates: Partial<CaptureState>): void;
+    getCapturedImages(): CapturedImages;
+    setCapturedImages(images: Partial<CapturedImages>): void;
+    reset(): void;
+    isProcessCompleted(): boolean;
+    canProceedToBack(): boolean;
+}

package/dist/types/services/strategies/HighPerformanceDeviceStrategy.d.ts

@@ -0,0 +1,6 @@
+import { IDeviceStrategy, DeviceInfo, SessionOptions } from './IDeviceStrategy';
+export declare class HighPerformanceDeviceStrategy implements IDeviceStrategy {
+    getDeviceInfo(): DeviceInfo;
+    getSessionOptions(debug: boolean): SessionOptions;
+    shouldUseSequentialLoading(): boolean;
+}

package/dist/types/services/strategies/IDeviceStrategy.d.ts

@@ -0,0 +1,21 @@
+export interface DeviceInfo {
+    estimatedRAM: number;
+    isLowMemory: boolean;
+    isSlowConnection: boolean;
+}
+export interface SessionOptions {
+    executionProviders: string[];
+    graphOptimizationLevel: string;
+    logSeverityLevel: number;
+    logVerbosityLevel?: number;
+    enableCpuMemArena: boolean;
+    enableMemPattern: boolean;
+    executionMode: string;
+    interOpNumThreads: number;
+    intraOpNumThreads: number;
+}
+export interface IDeviceStrategy {
+    getDeviceInfo(): DeviceInfo;
+    getSessionOptions(debug: boolean): SessionOptions;
+    shouldUseSequentialLoading(): boolean;
+}

package/dist/types/services/strategies/LowMemoryDeviceStrategy.d.ts

@@ -0,0 +1,6 @@
+import { IDeviceStrategy, DeviceInfo, SessionOptions } from './IDeviceStrategy';
+export declare class LowMemoryDeviceStrategy implements IDeviceStrategy {
+    getDeviceInfo(): DeviceInfo;
+    getSessionOptions(_debug: boolean): SessionOptions;
+    shouldUseSequentialLoading(): boolean;
+}

package/dist/types/types/component-types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Type definitions for component methods to avoid absolute paths in components.d.ts
+ */
+export interface CameraInfoResponse {
+    availableCameras: Array<{
+        id: string;
+        label: string;
+        selected: boolean;
+    }>;
+    selectedCameraId: string | null;
+    deviceType: string;
+    isMultipleCamerasAvailable: boolean;
+    preferredFacing: 'environment' | 'user' | null;
+}
+export interface CapturedImagesResponse {
+    front: {
+        fullFrame: string | null;
+        cropped: string | null;
+    };
+    back: {
+        fullFrame: string | null;
+        cropped: string | null;
+    };
+    metadata: {
+        totalImages: number;
+        processCompleted: boolean;
+        backCaptureSkipped: boolean;
+    };
+}
+export interface StatusResponse {
+    isVideoActive: boolean;
+    captureStep: 'front' | 'back' | 'completed';
+    hasImages: boolean;
+    isProcessCompleted: boolean;
+    isModelPreloaded: boolean;
+}