import { EventEmitter } from '../../stencil-public-runtime';
import { CameraInfoResponse, CapturedImagesResponse, StatusResponse } from '../../types/component-types';
export declare class JaakStamps {
    el: HTMLElement;
    debug: boolean;
    alignmentTolerance: number;
    maskSize: number;
    cropMargin: number;
    useDocumentClassification: boolean;
    useDocumentDetector: boolean;
    preferredCamera: 'auto' | 'front' | 'back';
    captureDelay: number;
    enableBackDocumentTimer: boolean;
    backDocumentTimerDuration: number;
    telemetryCollectorUrl?: string;
    metricsCollectorUrl?: string;
    enableTelemetry: boolean;
    enableMetrics: boolean;
    customerId?: string;
    tenantId?: string;
    environment?: string;
    propagateTraceHeaderCorsUrls?: string;
    metricsExportIntervalMillis?: number;
    license?: string;
    licenseEnvironment?: 'dev' | 'qa' | 'sandbox' | 'prod';
    traceId?: string;
    appId?: string;
    captureCompleted: EventEmitter<any>;
    isReady: EventEmitter<boolean>;
    traceIdGenerated: EventEmitter<{
        traceId: string;
    }>;
    detectionBoxes: Array<{
        x: number;
        y: number;
        w: number;
        h: number;
        score: number;
    }>;
    sideAlignment: {
        top: boolean;
        right: boolean;
        bottom: boolean;
        left: boolean;
    };
    isMaskReady: boolean;
    shouldMirrorVideo: boolean;
    showCameraSelector: boolean;
    isSwitchingCamera: boolean;
    hasDocumentDetected: boolean;
    cameraInfoWithAutofocus: {
        availableCameras: Array<{
            id: string;
            label: string;
            selected: boolean;
            hasAutofocus: boolean;
        }>;
        selectedCameraId: string | null;
        deviceType: string;
        isMultipleCamerasAvailable: boolean;
        preferredFacing: 'environment' | 'user' | null;
    };
    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;
    };
    backDocumentTimerRemaining: number;
    showManualCaptureButton: boolean;
    performanceDegradedMode: boolean;
    showPerformanceMessage: boolean;
    captureStateVersion: number;
    processingButton: 'capture-front' | 'capture-back' | 'skip-back' | null;
    licenseValid: boolean;
    licenseError: string | null;
    classificationDisabled: boolean;
    private licenseValidationService;
    private serviceContainer;
    private eventBus;
    private stateManager;
    private cameraService;
    private detectionService;
    private tracingService;
    private metricsService;
    private videoRef?;
    private detectionContainer?;
    private videoStream?;
    private animationId?;
    private lastDetectedBox?;
    private startTime?;
    private hasScreenshotTaken;
    private alignmentStartTime?;
    private alignmentTimer?;
    private backDocumentTimer?;
    private orientationTimer?;
    private performanceMetrics;
    private performanceUpdateInterval?;
    private frameSkipCounter;
    private readonly BASE_FRAME_SKIP;
    private readonly MAX_FRAME_SKIP;
    private consecutiveFailures;
    private readonly MAX_FAILURES;
    private lastInferenceTime;
    private readonly MIN_INFERENCE_INTERVAL;
    private readonly MOBILE_MIN_INFERENCE_INTERVAL;
    private performanceHistory;
    private readonly PERFORMANCE_HISTORY_SIZE;
    private readonly PERFORMANCE_THRESHOLD_MS;
    private readonly SLOW_FRAMES_TO_TRIGGER;
    private slowFrameCount;
    private processedFramesCount;
    private hasAutoSwitchedToManual;
    private _manualModeLoggedOnce;
    private readonly VIDEO_DIAGNOSTIC_EVENTS;
    private canvasPool;
    private readonly MAX_CANVAS_POOL_SIZE;
    componentWillLoad(): Promise<void>;
    componentDidLoad(): Promise<void>;
    private initializeServices;
    private validateLicense;
    private setupEventListeners;
    private initializeComponent;
    private validateProps;
    private readonly ORT_VERSION;
    private readonly ORT_CDN_BASE;
    private loadOnnxRuntime;
    private finalizeInitialization;
    private updateStatus;
    private emitReadyEvent;
    private checkCameraPermissions;
    private handleStateChange;
    private initializeResizeObserver;
    private handleResize;
    private triggerRerender;
    private getGuideText;
    private updateMaskDimensions;
    private isComponentReady;
    getCapturedImages(): Promise<CapturedImagesResponse>;
    isProcessCompleted(): Promise<boolean>;
    startCapture(): Promise<{
        success: boolean;
        error?: undefined;
    } | {
        success: boolean;
        error: any;
    }>;
    stopCapture(): Promise<{
        success: boolean;
        error?: undefined;
    } | {
        success: boolean;
        error: any;
    }>;
    resetCapture(): Promise<{
        success: boolean;
        error?: undefined;
    } | {
        success: boolean;
        error: any;
    }>;
    skipBackCapture(): Promise<{
        success: boolean;
        error?: undefined;
    } | {
        success: boolean;
        error: any;
    }>;
    getStatus(): Promise<StatusResponse>;
    preloadModel(): Promise<{
        success: boolean;
        message: string;
        error?: undefined;
    } | {
        success: boolean;
        error: any;
        message?: undefined;
    }>;
    getCameraInfo(): Promise<CameraInfoResponse>;
    setPreferredCamera(camera: 'auto' | 'front' | 'back'): Promise<{
        success: boolean;
        selectedCamera: string;
        availableCameras: number;
        error?: undefined;
    } | {
        success: boolean;
        error: any;
        selectedCamera: any;
        availableCameras: number;
    }>;
    setCaptureDelay(delay: number): Promise<{
        success: boolean;
        error: string;
        captureDelay: number;
    } | {
        success: boolean;
        captureDelay: number;
        error?: undefined;
    }>;
    getCaptureDelay(): Promise<number>;
    private checkDeviceCapabilities;
    private debugLog;
    private debugWarn;
    private summarizeId;
    private getCameraDevicesSnapshot;
    private sanitizeTrackSettings;
    private sanitizeTrackConstraints;
    private getStreamSnapshot;
    private getVideoElementSnapshot;
    private attachVideoDiagnosticListeners;
    private startDetection;
    private initializeVideoStream;
    private detectFrame;
    disconnectedCallback(): void;
    private cleanup;
    render(): any;
    private updateDetectionBoxes;
    private updateMaskColor;
    private takeManualScreenshot;
    private takeScreenshotWithMaskCoordinates;
    private takeScreenshot;
    private triggerCaptureAnimation;
    private switchToManualMode;
    private switchToManualModeWithWarning;
    private continueWithCameraSetup;
    private switchToManualModeWithError;
    private stopPerformanceMonitoring;
    private releaseOnnxResources;
    private completeProcess;
    private stopDetection;
    private startBackDocumentTimer;
    private clearBackDocumentTimer;
    private toggleCameraSelector;
    private updateCameraInfoWithAutofocus;
    private handleCameraSwitch;
    private resetDetection;
    private exitSession;
    private initializePerformanceMonitor;
    private updatePerformanceMetrics;
    private recordOnnxPerformance;
    private recordFrameProcessing;
    private getAdaptiveFrameSkip;
    private resetMaskToWhite;
    private getPooledCanvas;
    private returnCanvasToPool;
}