import { WorkerBridge } from "./worker/worker-bridge";
import { InitializationOptions } from "./model/configuration/initialization-options";
import { DocumentScannerViewConfiguration } from "./model/configuration/document-scanner-view-configuration";
import { BarcodeScannerViewConfiguration } from "./model/configuration/barcode-scanner-view-configuration";
import { CroppingViewConfiguration } from "./model/configuration/cropping-view-configuration";
import { IDocumentScannerHandle } from "./interfaces/i-document-scanner-handle";
import { IBarcodeScannerHandle } from "./interfaces/i-barcode-scanner-handle";
import { ICroppingViewHandle } from "./interfaces/i-cropping-view-handle";
import { PdfGenerator } from './service/pdf-generator';
import { TiffGenerator } from './service/tiff-generator';
import { PublicUtils } from "./service/public-utils";
import { MrzScannerViewConfiguration } from "./model/configuration/mrz-scanner-view-configuration";
import { IMrzScannerHandle } from "./interfaces/i-mrz-scanner-handle";
import { TextPatternScannerViewConfiguration } from "./model/configuration/text-pattern-scanner-view-configuration";
import { VinScannerViewConfiguration } from "./model/configuration/vin-scanner-view-configuration";
import { ITextPatternScannerHandle } from "./interfaces/i-text-pattern-scanner-handle";
import ScanbotSDKUI from "./ui2/scanbot-sdk-ui";
import { Image, DeepPartial, BarcodeScannerConfiguration, BarcodeDocumentFormat, MrzScannerConfiguration, DocumentQualityAnalyzerConfiguration, PdfConfiguration, TiffGeneratorParameters, DocumentDataExtractorConfiguration, BarcodeDocumentParserResult, DocumentQualityAnalyzer, CheckScannerConfiguration, DocumentScannerConfiguration, LicenseInfo, BridgeApiEntrypoint } from "./core-types";
import * as Config from "./core-types";
import { DocumentDataExtractorViewConfiguration } from "./model/configuration/document-data-extractor-view-configuration";
import { ConsumeType } from "./consume-type";
import { Stats } from "./utils/stats";
import { BrowserCameras } from "./utils/browser-cameras";
import { SBStorage } from "./service/storage/sb-storage";
import { ICheckScannerHandle } from "./interfaces/i-check-scanner-handle";
import { CheckScannerViewConfiguration } from "./model/configuration/check-scanner-view-configuration";
import { IDocumentDataExtractorHandle } from "./interfaces/i-document-data-extractor-handle";
import { CreditCardScannerViewConfiguration } from "./model/configuration/credit-card-scanner-view-configuration";
import { ICreditCardScannerHandle } from "./interfaces/i-credit-card-scanner-handle";
export default class ScanbotSDK {
    /** @internal */
    bridge: WorkerBridge;
    private initialized;
    private static defaultEnginePath;
    /** @internal */
    static instance: ScanbotSDK;
    private static _ui2;
    get API(): BridgeApiEntrypoint;
    static get UI(): typeof ScanbotSDKUI;
    static initialize(options: InitializationOptions): Promise<ScanbotSDK>;
    storage: SBStorage;
    /**
     * View Components
     */
    createDocumentScanner(configuration: DocumentScannerViewConfiguration): Promise<IDocumentScannerHandle>;
    createMrzScanner(configuration: MrzScannerViewConfiguration): Promise<IMrzScannerHandle>;
    createBarcodeScanner(configuration: BarcodeScannerViewConfiguration): Promise<IBarcodeScannerHandle>;
    createCheckScanner(config: CheckScannerViewConfiguration): Promise<ICheckScannerHandle>;
    createCreditCardScanner(config: CreditCardScannerViewConfiguration): Promise<ICreditCardScannerHandle>;
    openCroppingView(configuration: CroppingViewConfiguration): Promise<ICroppingViewHandle>;
    createTextPatternScanner(configuration: TextPatternScannerViewConfiguration): Promise<ITextPatternScannerHandle>;
    createVinScanner(configuration: VinScannerViewConfiguration): Promise<ITextPatternScannerHandle>;
    createDocumentQualityAnalyzer(configuration: DocumentQualityAnalyzerConfiguration): Promise<DocumentQualityAnalyzer>;
    createDocumentDataExtractor(config: DocumentDataExtractorViewConfiguration): Promise<IDocumentDataExtractorHandle>;
    /**
     * Image Operations
     */
    toDataUrl(imageBuffer: ArrayBuffer): Promise<string>;
    /**
     * @param image  {@displayType `Image`} {@link Image}
     * @param config {@displayType `DeepPartial<DocumentScannerConfiguration>`} {@link DocumentScannerConfiguration}
     * @param consumeType  {@displayType `ConsumeType`} {@link ConsumeType}
     */
    detectDocument(image: Image, config?: DeepPartial<DocumentScannerConfiguration>, consumeType?: ConsumeType): Promise<Config.DocumentDetectionResult | null>;
    detectAndCropDocument(image: Image, consumeImage?: ConsumeType): Promise<Config.DocumentScannerScanResponse | null>;
    /**
     * @param image An image URL (e.g. Data URL or HTTP URL) or an Image object
     * @param config {@displayType `DeepPartial<BarcodeScannerConfiguration>`} {@link BarcodeScannerConfiguration}
     * @param consumeType  {@displayType `ConsumeType`} {@link ConsumeType}
     * */
    detectBarcodes(image: string | Image, config?: DeepPartial<BarcodeScannerConfiguration>, consumeType?: ConsumeType): Promise<Config.BarcodeScannerResult>;
    parseBarcodeDocument(acceptedDocumentFormats: BarcodeDocumentFormat[], rawBarcodeData: string): Promise<BarcodeDocumentParserResult>;
    createCheckScannerEngine(config?: CheckScannerConfiguration): Promise<Config.CheckScanner>;
    createDocumentDataExtractorEngine(config?: DocumentDataExtractorConfiguration): Promise<Config.DocumentDataExtractor>;
    createMrzScannerEngine(config?: MrzScannerConfiguration): Promise<Config.MrzScanner>;
    createOcrEngine(): Promise<Config.OcrEngine>;
    createImageProcessor(): Promise<Config.ImageProcessor>;
    /**
     * Misc. Features
     */
    getLicenseInfo(): Promise<LicenseInfo>;
    /** @param options {@displayType `DeepPartial<PdfConfiguration>`} {@link PdfConfiguration}*/
    beginPdf(options: DeepPartial<PdfConfiguration>): Promise<PdfGenerator>;
    /** @param options {@displayType `DeepPartial<TiffGeneratorParameters>`} {@link TiffGeneratorParameters} */
    beginTiff(options?: DeepPartial<TiffGeneratorParameters>): Promise<TiffGenerator>;
    imageToJpeg(image: Image, consumeImage?: ConsumeType): Promise<Uint8Array>;
    get version(): string;
    private _utils;
    get utils(): PublicUtils;
    /** @internal */
    getBridge(consumeImage: ConsumeType): {
        __hasModuleFunction: (functionName: string) => Promise<any>;
        __callModuleFunction: (functionName: string, args?: any[]) => Promise<any>;
        BarcodeDocumentParser: Config.WorkerBarcodeDocumentParser;
        BarcodeScanner: Config.WorkerBarcodeScanner;
        CheckScanner: Config.WorkerCheckScanner;
        CreditCardScanner: Config.WorkerCreditCardScanner;
        DocumentClassifier: Config.WorkerDocumentClassifier;
        DocumentDataExtractor: Config.WorkerDocumentDataExtractor;
        DocumentEnhancer: Config.WorkerDocumentEnhancer;
        DocumentQualityAnalyzer: Config.WorkerDocumentQualityAnalyzer;
        DocumentScanner: Config.WorkerDocumentScanner;
        ImageManipulator: Config.WorkerImageManipulator;
        ImageProcessor: Config.WorkerImageProcessor;
        MrzScanner: Config.WorkerMrzScanner;
        MrzParser: Config.WorkerMrzParser;
        OcrEngine: Config.WorkerOcrEngine;
        TextPatternScanner: Config.WorkerTextPatternScanner;
        VinScanner: Config.WorkerVinScanner;
        initialize: (licenseKey?: string, enginePath?: string, appId?: string, options?: Config.InitializeOptions) => Promise<void>;
        getLicenseInfo: () => Promise<LicenseInfo>;
        encodeJpeg: (image: Image, quality?: number) => Promise<Uint8Array>;
        beginPdf: (options: {
            attributes?: {
                author?: string;
                creator?: string;
                title?: string;
                subject?: string;
                keywords?: string;
            };
            pageSize?: Config.PageSize;
            pageDirection?: Config.PageDirection;
            pageFit?: Config.PageFit;
            dpi?: number;
            jpegQuality?: number;
            jpegOptimize?: boolean;
            resamplingMethod?: Config.ResamplingMethod;
            binarizationFilter?: ({
                filterType?: number;
            } & {
                readonly _type: "LegacyFilter";
            }) | ({
                outputMode?: Config.OutputMode;
            } & {
                readonly _type: "ScanbotBinarizationFilter";
            }) | ({
                outputMode?: Config.OutputMode;
                denoise?: number;
                radius?: number;
                preset?: Config.BinarizationFilterPreset;
            } & {
                readonly _type: "CustomBinarizationFilter";
            }) | ({
                contrastEnhancement?: number;
                colorEnhancement?: number;
                paperWhitening?: number;
                paperWhiteningBias?: number;
            } & {
                readonly _type: "ColorDocumentFilter";
            }) | ({
                contrastEnhancement?: number;
                colorEnhancement?: number;
                paperSaturation?: number;
                paperLightness?: number;
            } & {
                readonly _type: "ColorDocumentShadowRemovalFilter";
            }) | ({
                brightness?: number;
            } & {
                readonly _type: "BrightnessFilter";
            }) | ({
                contrast?: number;
            } & {
                readonly _type: "ContrastFilter";
            }) | ({
                borderWidthFraction?: number;
                blackOutliersFraction?: number;
                whiteOutliersFraction?: number;
            } & {
                readonly _type: "GrayscaleFilter";
            }) | ({
                blackPoint?: number;
                whitePoint?: number;
            } & {
                readonly _type: "WhiteBlackPointFilter";
            });
        }) => Promise<Config.ObjectId<"PdfGenerationContext">>;
        addPageToPdf: (pdfOperation: Config.ObjectId<"PdfGenerationContext">, image: Image, binarization?: Config.PageBinarization) => Promise<void>;
        addPageToPdfWithOcr: (pdfOperation: Config.ObjectId<"PdfGenerationContext">, image: Image, binarization?: Config.PageBinarization) => Promise<void>;
        completePdf: (pdfOperation: Config.ObjectId<"PdfGenerationContext">) => Promise<Uint8Array>;
        discardPdf: (pdfOperation: Config.ObjectId<"PdfGenerationContext">) => Promise<void>;
        beginTiff: (options: {
            compression?: Config.CompressionMode;
            jpegQuality?: number;
            zipCompressionLevel?: number;
            dpi?: number;
            userFields?: {
                tag?: number;
                name?: string;
                value?: ({
                    value?: number;
                } & {
                    readonly _type: "UserFieldDoubleValue";
                }) | ({
                    value?: string;
                } & {
                    readonly _type: "UserFieldStringValue";
                }) | ({
                    value?: number;
                } & {
                    readonly _type: "UserFieldIntValue";
                });
            }[];
            binarizationFilter?: ({
                filterType?: number;
            } & {
                readonly _type: "LegacyFilter";
            }) | ({
                outputMode?: Config.OutputMode;
            } & {
                readonly _type: "ScanbotBinarizationFilter";
            }) | ({
                outputMode?: Config.OutputMode;
                denoise?: number;
                radius?: number;
                preset?: Config.BinarizationFilterPreset;
            } & {
                readonly _type: "CustomBinarizationFilter";
            }) | ({
                contrastEnhancement?: number;
                colorEnhancement?: number;
                paperWhitening?: number;
                paperWhiteningBias?: number;
            } & {
                readonly _type: "ColorDocumentFilter";
            }) | ({
                contrastEnhancement?: number;
                colorEnhancement?: number;
                paperSaturation?: number;
                paperLightness?: number;
            } & {
                readonly _type: "ColorDocumentShadowRemovalFilter";
            }) | ({
                brightness?: number;
            } & {
                readonly _type: "BrightnessFilter";
            }) | ({
                contrast?: number;
            } & {
                readonly _type: "ContrastFilter";
            }) | ({
                borderWidthFraction?: number;
                blackOutliersFraction?: number;
                whiteOutliersFraction?: number;
            } & {
                readonly _type: "GrayscaleFilter";
            }) | ({
                blackPoint?: number;
                whitePoint?: number;
            } & {
                readonly _type: "WhiteBlackPointFilter";
            });
        }) => Promise<Config.ObjectId<"TiffGenerationContext">>;
        addPageToTiff: (tiffOperation: Config.ObjectId<"TiffGenerationContext">, image: Image, binarization: Config.PageBinarization) => Promise<void>;
        completeTiff: (tiffOperation: Config.ObjectId<"TiffGenerationContext">) => Promise<Uint8Array>;
        discardTiff: (tiffOperation: Config.ObjectId<"TiffGenerationContext">) => Promise<void>;
        version: () => Promise<string>;
    };
    private licenseCheck;
    static cameras: BrowserCameras;
    static Config: typeof Config;
    /**
     * Used for testing purposes only.
     * @internal
     */
    static _stats: Stats;
}