id-scanner-lib/dist/types/index.bundle.d.ts

Browser-based ID card, QR code, and face recognition scanner with liveness detection

/**
 * @file 事件发射器
 * @description 提供基础的事件发射和订阅功能
 * @module core/event-emitter
 */
/**
 * 事件处理器类型
 */
type EventHandler = (data?: any) => void;
/**
 * 事件发射器基类
 * 提供基础的事件发射和订阅功能
 */
declare class EventEmitter {
    /** 事件处理器映射 */
    private eventHandlers;
    /**
     * 订阅事件
     * @param eventName 事件名称
     * @param handler 事件处理器
     */
    on(eventName: string, handler: EventHandler): void;
    /**
     * 取消订阅事件
     * @param eventName 事件名称
     * @param handler 事件处理器，如果不提供则移除该事件的所有处理器
     */
    off(eventName: string, handler?: EventHandler): void;
    /**
     * 订阅事件，但只触发一次
     * @param eventName 事件名称
     * @param handler 事件处理器
     */
    once(eventName: string, handler: EventHandler): void;
    /**
     * 发射事件
     * @param eventName 事件名称
     * @param data 事件数据
     */
    emit(eventName: string, data?: any): void;
    /**
     * 获取某个事件的处理器数量
     * @param eventName 事件名称
     */
    listenerCount(eventName: string): number;
    /**
     * 移除所有事件处理器
     */
    removeAllListeners(): void;
    /**
     * 获取所有事件名称
     */
    eventNames(): string[];
}

/**
 * @file 日志系统
 * @description 提供统一的日志记录与管理功能
 * @module core/logger
 */
/**
 * 日志级别枚举
 */
declare enum LogLevel {
    DEBUG = "debug",
    INFO = "info",
    WARN = "warn",
    ERROR = "error"
}
/**
 * 日志条目接口
 */
interface LogEntry {
    /** 日志级别 */
    level: LogLevel;
    /** 日志标签 */
    tag: string;
    /** 日志消息 */
    message: string;
    /** 时间戳 */
    timestamp: number;
    /** 额外数据 */
    data?: any;
    /** 错误 */
    error?: Error;
}
/**
 * 日志处理器接口
 */
interface LogHandler {
    /**
     * 处理日志条目
     * @param entry 日志条目
     */
    handle(entry: LogEntry): void;
}
/**
 * 控制台日志处理器
 * 将日志输出到浏览器控制台
 */
declare class ConsoleLogHandler implements LogHandler {
    /**
     * 处理日志条目
     * @param entry 日志条目
     */
    handle(entry: LogEntry): void;
}
/**
 * 内存日志处理器
 * 将日志保存在内存中，用于后续分析或显示
 */
declare class MemoryLogHandler implements LogHandler {
    /** 日志条目数组 */
    private entries;
    /** 最大日志条目数 */
    private maxEntries;
    /**
     * 构造函数
     * @param maxEntries 最大日志条目数，默认为1000
     */
    constructor(maxEntries?: number);
    /**
     * 处理日志条目
     * @param entry 日志条目
     */
    handle(entry: LogEntry): void;
    /**
     * 获取所有日志条目
     */
    getEntries(): LogEntry[];
    /**
     * 根据级别过滤日志条目
     * @param level 日志级别
     */
    getEntriesByLevel(level: LogLevel): LogEntry[];
    /**
     * 根据标签过滤日志条目
     * @param tag 日志标签
     */
    getEntriesByTag(tag: string): LogEntry[];
    /**
     * 清空日志
     */
    clear(): void;
}
/**
 * 远程日志处理器
 * 将日志发送到远程服务器
 */
declare class RemoteLogHandler implements LogHandler {
    /** 远程服务器URL */
    private endpoint;
    /** 批量发送的队列 */
    private queue;
    /** 最大队列长度 */
    private maxQueueSize;
    /** 发送间隔(毫秒) */
    private flushInterval;
    /** 定时发送的计时器ID */
    private timerId;
    /**
     * 构造函数
     * @param endpoint 远程服务器URL
     * @param maxQueueSize 最大队列长度，默认为100
     * @param flushInterval 发送间隔(毫秒)，默认为5000
     */
    constructor(endpoint: string, maxQueueSize?: number, flushInterval?: number);
    /**
     * 处理日志条目
     * @param entry 日志条目
     */
    handle(entry: LogEntry): void;
    /**
     * 发送队列中的日志
     */
    flush(): void;
    /**
     * 开始定时发送
     */
    startTimer(): void;
    /**
     * 停止定时发送
     */
    stopTimer(): void;
}
/**
 * 日志管理类
 * 中央日志管理器，提供统一的日志记录接口
 */
declare class Logger {
    /** 单例实例 */
    private static instance;
    /** 配置管理器 */
    private config;
    /** 日志处理器 */
    private handlers;
    /** 默认标签 */
    private defaultTag;
    /** 日志级别 */
    private logLevel;
    /**
     * 私有构造函数，防止直接实例化
     */
    private constructor();
    /**
     * 获取单例实例
     */
    static getInstance(): Logger;
    /**
     * 添加日志处理器
     * @param handler 日志处理器
     */
    addHandler(handler: LogHandler): void;
    /**
     * 移除日志处理器
     * @param handler 要移除的处理器
     */
    removeHandler(handler: LogHandler): void;
    /**
     * 移除所有处理器
     */
    clearHandlers(): void;
    /**
     * 设置默认标签
     * @param tag 默认标签
     */
    setDefaultTag(tag: string): void;
    /**
     * 记录调试级别日志
     * @param tag 标签
     * @param message 消息
     * @param error 错误
     */
    debug(tag: string, message: string, error?: Error): void;
    /**
     * 记录信息级别日志
     * @param tag 标签
     * @param message 消息
     * @param error 错误
     */
    info(tag: string, message: string, error?: Error): void;
    /**
     * 记录警告级别日志
     * @param tag 标签
     * @param message 消息
     * @param error 错误
     */
    warn(tag: string, message: string, error?: Error): void;
    /**
     * 记录错误级别日志
     * @param tag 标签
     * @param message 消息
     * @param error 错误
     */
    error(tag: string, message: string, error?: Error): void;
    /**
     * 创建标记了特定标签的日志记录器
     * @param tag 标签
     */
    getTaggedLogger(tag: string): TaggedLogger;
    /**
     * 记录日志
     * @param level 日志级别
     * @param tag 标签
     * @param message 消息
     * @param error 错误
     */
    private log;
    /**
     * 控制台输出
     * @param entry 日志条目
     */
    private consoleOutput;
    /**
     * 获取日志级别值
     * @param level 日志级别
     */
    private getLevelValue;
    /**
     * 设置日志级别
     * @param level 日志级别
     */
    setLevel(level: LogLevel | string): void;
    /**
     * 获取当前日志级别
     * @returns 当前日志级别
     */
    getLevel(): LogLevel;
}
/**
 * 带标签的日志记录器
 * 提供特定标签的简易日志接口
 */
declare class TaggedLogger {
    /** 所属的主日志记录器 */
    private logger;
    /** 标签 */
    private tag;
    /**
     * 构造函数
     * @param logger 所属的主日志记录器
     * @param tag 标签
     */
    constructor(logger: Logger, tag: string);
    /**
     * 记录调试级别日志
     * @param message 消息
     * @param error 错误
     */
    debug(message: string, error?: Error): void;
    /**
     * 记录信息级别日志
     * @param message 消息
     * @param error 错误
     */
    info(message: string, error?: Error): void;
    /**
     * 记录警告级别日志
     * @param message 消息
     * @param error 错误
     */
    warn(message: string, error?: Error): void;
    /**
     * 记录错误级别日志
     * @param message 消息
     * @param error 错误
     */
    error(message: string, error?: Error): void;
}

/**
 * @file 模块管理器
 * @description 统一管理库的各功能模块，提供模块的注册、初始化和卸载功能
 * @module core/module-manager
 */

/**
 * 模块接口
 * 所有功能模块必须实现此接口
 */
interface Module {
    /** 模块名称 */
    name: string;
    /** 模块版本 */
    version: string;
    /** 模块是否已初始化 */
    isInitialized: boolean;
    /** 初始化模块 */
    initialize(): Promise<void>;
    /** 释放模块资源 */
    dispose(): Promise<void>;
}
/**
 * 模块配置接口
 */
interface ModuleOptions {
    /** 是否启用该模块 */
    enabled?: boolean;
    /** 模块特定配置 */
    [key: string]: any;
}
/**
 * 模块管理器类
 * 负责管理所有功能模块的生命周期
 */
declare class ModuleManager extends EventEmitter {
    private static instance;
    private modules;
    private logger;
    private initialized;
    /**
     * 获取模块管理器单例
     */
    static getInstance(): ModuleManager;
    /**
     * 私有构造函数，确保单例模式
     */
    private constructor();
    /**
     * 注册模块
     * @param module 要注册的模块
     * @returns 模块管理器实例，支持链式调用
     */
    register(module: Module): ModuleManager;
    /**
     * 获取模块
     * @param name 模块名称
     * @returns 模块实例
     */
    getModule<T extends Module>(name: string): T | undefined;
    /**
     * 初始化所有注册的模块
     */
    initialize(): Promise<void>;
    /**
     * 卸载所有模块并释放资源
     */
    dispose(): Promise<void>;
    /**
     * 获取所有已注册的模块名称
     */
    getRegisteredModules(): string[];
    /**
     * 检查模块是否已注册
     * @param name 模块名称
     */
    hasModule(name: string): boolean;
}

/**
 * @file 基础模块
 * @description 提供基础模块实现，作为所有功能模块的基类
 * @module core/base-module
 */

/**
 * 基础模块类
 * 提供模块的基本功能和生命周期管理
 */
declare abstract class BaseModule extends EventEmitter implements Module {
    /** 模块名称 */
    abstract readonly name: string;
    /** 模块版本 */
    readonly version: string;
    /** 模块是否已初始化 */
    protected _isInitialized: boolean;
    /** 日志工具 */
    protected logger: Logger;
    /**
     * 构造函数
     */
    constructor();
    /**
     * 获取模块是否已初始化
     */
    get isInitialized(): boolean;
    /**
     * 初始化模块
     * 子类必须实现此方法
     */
    abstract initialize(): Promise<void>;
    /**
     * 释放模块资源
     * 子类可以覆盖此方法以添加额外的资源释放逻辑
     */
    dispose(): Promise<void>;
    /**
     * 检查模块是否已初始化，如果未初始化则抛出错误
     */
    protected ensureInitialized(): void;
}

/**
 * @file 身份证模块类型定义
 * @description 身份证模块相关的类型和接口定义
 * @module modules/id-card/types
 */
/**
 * 身份证类型枚举
 */
declare enum IDCardType {
    /** 第二代居民身份证正面 */
    FRONT = "front",
    /** 第二代居民身份证背面 */
    BACK = "back",
    /** 第一代居民身份证 */
    FIRST_GENERATION = "first_generation",
    /** 临时身份证 */
    TEMPORARY = "temporary",
    /** 外国人永久居留证 */
    FOREIGN_PERMANENT = "foreign_permanent",
    /** 港澳台居民居住证 */
    HMT_RESIDENT = "hmt_resident",
    /** 未知类型 */
    UNKNOWN = "unknown"
}
/**
 * 证件边缘信息
 */
interface IDCardEdge {
    /** 左上角坐标 */
    topLeft: {
        x: number;
        y: number;
    };
    /** 右上角坐标 */
    topRight: {
        x: number;
        y: number;
    };
    /** 右下角坐标 */
    bottomRight: {
        x: number;
        y: number;
    };
    /** 左下角坐标 */
    bottomLeft: {
        x: number;
        y: number;
    };
}
/**
 * 身份证信息
 */
interface IDCardInfo {
    nationality?: string;
    issuingAuthority?: string;
    validPeriod?: string;
    /** 身份证类型 */
    type?: IDCardType;
    /** 身份证边缘信息 */
    edge?: IDCardEdge;
    /** 姓名 */
    name?: string;
    /** 性别 */
    gender?: string;
    /** 民族 */
    ethnicity?: string;
    /** 出生日期，格式: YYYY-MM-DD */
    birthDate?: string;
    /** 地址 */
    address?: string;
    /** 身份证号码 */
    idNumber?: string;
    /** 签发机关 */
    issueAuthority?: string;
    /** 有效期起始日期，格式: YYYY-MM-DD */
    validFrom?: string;
    /** 有效期截止日期，格式: YYYY-MM-DD */
    validTo?: string;
    /** 相片区域坐标 */
    photoRegion?: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    /** 原始身份证图像 */
    image?: ImageData;
    /** 置信度 */
    confidence?: number;
    /** 防伪检测结果 */
    antiFake?: {
        /** 是否通过防伪检测 */
        passed: boolean;
        /** 防伪检测分数 */
        score: number;
        /** 防伪特征检测结果 */
        features?: {
            /** 荧光油墨 */
            fluorescent?: boolean;
            /** 微缩文字 */
            microtext?: boolean;
            /** 光变图案 */
            opticalVariable?: boolean;
            /** 纹理 */
            texture?: boolean;
            /** 暗记 */
            watermark?: boolean;
        };
    };
}
/**
 * 身份证模块配置选项
 */
interface IDCardModuleOptions {
    /** 是否启用模块 */
    enabled?: boolean;
    /** 检测器配置 */
    detector?: {
        /** 最小置信度 */
        minConfidence?: number;
        /** 是否启用OCR识别 */
        enableOCR?: boolean;
        /** 是否启用防伪检测 */
        enableAntiFake?: boolean;
    };
    /** OCR处理器配置 */
    ocr?: {
        /** 是否使用Web Worker处理OCR */
        useWorker?: boolean;
        /** 最大图像尺寸 */
        maxImageDimension?: number;
        /** 亮度调整 */
        brightness?: number;
        /** 对比度调整 */
        contrast?: number;
    };
    /** 防伪检测配置 */
    antiFake?: {
        /** 防伪检测灵敏度 */
        sensitivity?: number;
        /** 最小置信度 */
        minConfidence?: number;
    };
}
/**
 * 身份证验证结果
 */
interface IDCardVerificationResult {
    /** 是否验证通过 */
    isValid: boolean;
    /** 验证分数 */
    score: number;
    /** 失败原因 */
    failureReason?: string;
    /** 验证详情 */
    details?: {
        /** 身份证号码是否有效 */
        idNumberValid?: boolean;
        /** 签发日期是否有效 */
        issueDateValid?: boolean;
        /** 有效期是否过期 */
        isExpired?: boolean;
        /** 防伪检测是否通过 */
        antiFakePassed?: boolean;
    };
}

/**
 * @file 身份证模块入口
 * @description 提供身份证识别和验证功能的模块入口
 * @module modules/id-card
 */

/**
 * 身份证识别模块
 * 提供身份证检测、OCR识别、防伪检测等功能
 */
declare class IDCardModule extends BaseModule {
    /** 模块名称 */
    readonly name: string;
    /** 模块配置 */
    private options;
    /** 身份证检测器 */
    private detector;
    /** OCR处理器 */
    private ocrProcessor?;
    /** 防伪检测器 */
    private antiFakeDetector?;
    /** 最后一次检测结果 */
    private lastDetectionResult?;
    /**
     * 构造函数
     * @param options 模块配置选项
     */
    constructor(options?: IDCardModuleOptions);
    /**
     * 初始化模块
     */
    initialize(): Promise<void>;
    /**
     * 识别身份证图像
     * @param image 图像源
     * @returns 识别结果
     */
    recognize(image: ImageData | HTMLImageElement | HTMLCanvasElement): Promise<IDCardInfo>;
    /**
     * 验证身份证信息
     * @param idCardInfo 身份证信息
     * @returns 验证结果
     */
    verify(idCardInfo: IDCardInfo): IDCardVerificationResult;
    /**
     * 获取最后一次识别结果
     */
    getLastRecognitionResult(): IDCardInfo | undefined;
    /**
     * 释放模块资源
     */
    dispose(): Promise<void>;
    /**
     * 验证身份证号码是否有效
     * @param idNumber 身份证号码
     * @returns 是否有效
     */
    private validateIDNumber;
    /**
     * 检查身份证是否过期
     * @param validTo 有效期截止日期
     * @returns 是否过期
     */
    private isIDCardExpired;
    /**
     * 检测身份证
     * @param image 图像源
     * @returns 检测结果
     */
    detect(image: ImageData | HTMLImageElement | HTMLCanvasElement): Promise<{
        success: boolean;
        type?: IDCardType;
        confidence: number;
        croppedImage?: ImageData;
    }>;
    /**
     * 将图像转换为 ImageData
     * @param image 图像源
     * @returns ImageData 对象
     */
    private convertToImageData;
    /**
     * 确保模块已初始化
     * @protected
     */
    protected ensureInitialized(): void;
}

/**
 * @file 二维码模块类型定义
 * @description 二维码模块相关的类型和接口定义
 * @module modules/qrcode/types
 */
/**
 * 二维码检测结果
 */
interface QRCodeResult {
    /** 二维码内容 */
    data: string;
    /** 二维码类型 */
    type?: string;
    /** 二维码边界框 */
    boundingBox: {
        topLeft: {
            x: number;
            y: number;
        };
        topRight: {
            x: number;
            y: number;
        };
        bottomRight: {
            x: number;
            y: number;
        };
        bottomLeft: {
            x: number;
            y: number;
        };
    };
    /** 二维码中心点 */
    center: {
        x: number;
        y: number;
    };
    /** 原始图像 */
    image?: ImageData;
    /** 置信度 */
    confidence?: number;
}
/**
 * 二维码模块选项
 */
interface QRCodeModuleOptions {
    /** 是否启用模块 */
    enabled?: boolean;
    /** 二维码扫描配置 */
    scanner?: {
        /** 最小置信度 */
        minConfidence?: number;
        /** 是否尝试多次扫描 */
        tryMultipleScan?: boolean;
        /** 是否返回原始图像 */
        returnImage?: boolean;
    };
    /** 图像处理配置 */
    imageProcess?: {
        /** 是否进行预处理 */
        preprocess?: boolean;
        /** 是否增强对比度 */
        enhanceContrast?: boolean;
        /** 二值化阈值 */
        threshold?: number;
    };
}

/**
 * @file 二维码模块入口
 * @description 提供二维码识别和解析功能的模块入口
 * @module modules/qrcode
 */

/**
 * 二维码模块
 * 提供二维码检测和解析功能
 */
declare class QRCodeModule extends BaseModule {
    /** 模块名称 */
    readonly name: string;
    /** 模块配置 */
    private options;
    /** 二维码扫描器 */
    private scanner;
    /** 最后一次扫描结果 */
    private lastScanResult?;
    /**
     * 构造函数
     * @param options 模块配置选项
     */
    constructor(options?: QRCodeModuleOptions);
    /**
     * 初始化模块
     */
    initialize(): Promise<void>;
    /**
     * 扫描图像中的二维码
     * @param image 图像源
     * @returns 二维码扫描结果
     */
    scan(image: ImageData | HTMLImageElement | HTMLCanvasElement): Promise<QRCodeResult | undefined>;
    /**
     * 获取最后一次扫描结果
     */
    getLastScanResult(): QRCodeResult | undefined;
    /**
     * 解析二维码数据
     * @param data 二维码数据
     * @returns 解析后的数据对象
     */
    parseQRCodeData(data: string): Record<string, any> | string;
    /**
     * 释放模块资源
     */
    dispose(): Promise<void>;
}

/**
 * @file 人脸模块类型定义
 * @description 人脸模块相关的类型和接口定义
 * @module modules/face/types
 */
/**
 * 人脸检测结果
 */
interface FaceDetectionResult {
    /** 人脸边界框 */
    boundingBox: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    /** 人脸特征点 */
    landmarks?: {
        /** 左眼 */
        leftEye: {
            x: number;
            y: number;
        };
        /** 右眼 */
        rightEye: {
            x: number;
            y: number;
        };
        /** 鼻子 */
        nose: {
            x: number;
            y: number;
        };
        /** 嘴巴 */
        mouth: {
            x: number;
            y: number;
        };
        /** 下巴 */
        chin: {
            x: number;
            y: number;
        };
    };
    /** 人脸角度 */
    angle?: {
        /** 俯仰角 */
        pitch: number;
        /** 偏航角 */
        yaw: number;
        /** 翻滚角 */
        roll: number;
    };
    /** 人脸属性 */
    attributes?: {
        /** 性别 */
        gender?: {
            /** 性别值 */
            value: 'male' | 'female';
            /** 置信度 */
            confidence: number;
        };
        /** 年龄 */
        age?: {
            /** 年龄值 */
            value: number;
            /** 置信度 */
            confidence: number;
        };
        /** 表情 */
        emotion?: {
            /** 表情值 */
            value: 'neutral' | 'happiness' | 'surprise' | 'sadness' | 'anger' | 'disgust' | 'fear' | 'contempt';
            /** 置信度 */
            confidence: number;
        };
    };
    /** 活体检测结果 */
    liveness?: {
        /** 是否通过活体检测 */
        passed: boolean;
        /** 活体检测分数 */
        score: number;
        /** 活体检测类型 */
        type: 'blink' | 'mouth' | 'head' | 'passive';
    };
    /** 人脸图像 */
    image?: ImageData;
    /** 置信度 */
    confidence: number;
}
/**
 * 人脸比对结果
 */
interface FaceComparisonResult {
    /** 是否匹配 */
    isMatch: boolean;
    /** 相似度分数 */
    similarity: number;
    /** 置信度 */
    confidence: number;
}
/**
 * 人脸模块配置选项
 */
interface FaceModuleOptions {
    /** 是否启用模块 */
    enabled?: boolean;
    /** 检测器配置 */
    detector?: {
        /** 最小置信度 */
        minConfidence?: number;
        /** 是否检测特征点 */
        detectLandmarks?: boolean;
        /** 是否检测属性 */
        detectAttributes?: boolean;
        /** 是否返回人脸图像 */
        returnFaceImage?: boolean;
    };
    /** 活体检测配置 */
    liveness?: {
        /** 是否启用活体检测 */
        enabled?: boolean;
        /** 活体检测类型 */
        type?: 'blink' | 'mouth' | 'head' | 'passive';
        /** 最小置信度 */
        minConfidence?: number;
        /** 检测超时时间（毫秒） */
        timeout?: number;
    };
    /** 人脸比对配置 */
    comparison?: {
        /** 最小相似度阈值 */
        minSimilarity?: number;
    };
}

/**
 * @file 人脸模块入口
 * @description 提供人脸检测、活体检测和人脸比对功能的模块入口
 * @module modules/face
 */

/**
 * 人脸模块
 * 提供人脸检测、活体检测和人脸比对功能
 */
declare class FaceModule extends BaseModule {
    /** 模块名称 */
    readonly name: string;
    /** 模块配置 */
    private options;
    /** 最后一次检测结果 */
    private lastDetectionResult?;
    /**
     * 构造函数
     * @param options 模块配置选项
     */
    constructor(options?: FaceModuleOptions);
    /**
     * 初始化模块
     */
    initialize(): Promise<void>;
    /**
     * 检测图像中的人脸
     * @param image 图像源
     * @returns 人脸检测结果
     */
    detectFace(image: ImageData | HTMLImageElement | HTMLCanvasElement): Promise<FaceDetectionResult | undefined>;
    /**
     * 进行活体检测
     * @param image 图像源
     * @returns 活体检测结果
     */
    detectLiveness(image: ImageData | HTMLImageElement | HTMLCanvasElement): Promise<boolean>;
    /**
     * 比对两个人脸
     * @param face1 第一个人脸图像
     * @param face2 第二个人脸图像
     * @returns 人脸比对结果
     */
    compareFaces(face1: ImageData | HTMLImageElement | HTMLCanvasElement, face2: ImageData | HTMLImageElement | HTMLCanvasElement): Promise<FaceComparisonResult>;
    /**
     * 获取最后一次检测结果
     */
    getLastDetectionResult(): FaceDetectionResult | undefined;
    /**
     * 释放模块资源
     */
    dispose(): Promise<void>;
}

/**
 * @file 错误处理模块
 * @description 定义ID-Scanner-Lib的错误类层次结构
 * @module core/errors
 */
/**
 * ID-Scanner-Lib 基础错误类
 * 所有库特定错误的基类
 */
declare class IDScannerError extends Error {
    /** 错误代码 */
    code: string;
    /** 错误原因 */
    cause?: Error;
    /**
     * 构造函数
     * @param message 错误消息
     * @param options 错误选项
     */
    constructor(message: string, options?: {
        code?: string;
        cause?: Error;
    });
}
/**
 * 初始化错误
 * 当库初始化失败时抛出
 */
declare class InitializationError extends IDScannerError {
    constructor(message: string, details?: string);
}
/**
 * 设备错误
 * 当访问硬件设备(如摄像头)失败时抛出
 */
declare class DeviceError extends IDScannerError {
    constructor(message: string);
}
/**
 * 摄像头访问错误
 * 当无法访问或启动摄像头时抛出
 */
declare class CameraAccessError extends IDScannerError {
    constructor(message: string, options?: {
        code?: string;
        cause?: Error;
    });
}
/**
 * 人脸检测错误
 * 当人脸检测过程失败时抛出
 */
declare class FaceDetectionError extends IDScannerError {
    constructor(message: string);
}
/**
 * 人脸比对错误
 * 当人脸比对过程失败时抛出
 */
declare class FaceComparisonError extends IDScannerError {
    constructor(message: string);
}
/**
 * 活体检测错误
 * 当活体检测过程失败时抛出
 */
declare class LivenessDetectionError extends IDScannerError {
    constructor(message: string);
}
/**
 * OCR识别错误
 * 当OCR文字识别失败时抛出
 */
declare class OCRProcessingError extends IDScannerError {
    constructor(message: string);
}
/**
 * 二维码扫描错误
 * 当二维码扫描失败时抛出
 */
declare class QRScanError extends IDScannerError {
    constructor(message: string);
}
/**
 * 身份证检测错误
 * 当身份证检测失败时抛出
 */
declare class IDCardDetectionError extends IDScannerError {
    constructor(message: string);
}
/**
 * 资源加载错误
 * 当无法加载必要资源(如模型)时抛出
 */
declare class ResourceLoadError extends IDScannerError {
    constructor(resource: string, reason: string);
}
/**
 * 参数错误
 * 当提供的参数无效时抛出
 */
declare class InvalidArgumentError extends IDScannerError {
    constructor(paramName: string, reason: string);
}
/**
 * 不支持错误
 * 当尝试使用不支持的功能或当前环境无法使用的功能时抛出
 */
declare class NotSupportedError extends IDScannerError {
    constructor(feature: string);
}

/**
 * @file 类型定义文件
 * @description 定义全局类型
 * @module Types
 */
/**
 * 身份证检测结果接口
 *
 * 包含身份证检测的结果信息，如是否成功检测到身份证、身份证的四个角点坐标以及裁剪后的身份证图像
 *
 * @interface DetectionResult
 * @property {boolean} success - 是否成功检测到身份证
 * @property {Object[]} [corners] - 检测到的身份证四个角点坐标
 * @property {number} corners[].x - 角点X坐标
 * @property {number} corners[].y - 角点Y坐标
 * @property {ImageData} [croppedImage] - 裁剪后的身份证图像
 * @property {ImageData} [imageData] - 原始图像数据
 * @property {Object} [boundingBox] - 检测到的身份证边界框
 * @property {number} boundingBox.x - 边界框左上角X坐标
 * @property {number} boundingBox.y - 边界框左上角Y坐标
 * @property {number} boundingBox.width - 边界框宽度
 * @property {number} boundingBox.height - 边界框高度
 * @property {number} [confidence] - 检测结果的置信度
 * @property {string} [message] - 检测结果的消息
 */
interface DetectionResult {
    success: boolean;
    corners?: {
        x: number;
        y: number;
    }[];
    croppedImage?: ImageData;
    imageData?: ImageData;
    boundingBox?: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    confidence?: number;
    message?: string;
}
/**
 * 点坐标
 */
interface Point {
    x: number;
    y: number;
}
/**
 * 矩形区域
 */
interface Rect {
    x: number;
    y: number;
    width: number;
    height: number;
}
/**
 * 可释放资源接口
 */
interface Disposable {
    /** 释放资源 */
    dispose(): Promise<void>;
}
/**
 * 图像处理选项
 */
interface ImageProcessingOptions {
    /** 亮度调整 (-100 到 100) */
    brightness?: number;
    /** 对比度调整 (-100 到 100) */
    contrast?: number;
    /** 饱和度调整 (-100 到 100) */
    saturation?: number;
    /** 锐化强度 (0 到 10) */
    sharpen?: number | boolean;
    /** 高斯模糊半径 (0 到 10) */
    blur?: number;
    /** 是否应用灰度转换 */
    grayscale?: boolean;
    /** 是否应用二值化 */
    binarize?: boolean;
    /** 二值化阈值 (0 到 255) */
    threshold?: number;
    /** 是否应用边缘检测 */
    edgeDetection?: boolean;
    /** 是否应用降噪 */
    denoise?: boolean;
    /** 是否应用直方图均衡化 */
    histogramEqualization?: boolean;
    /** 是否应用透视校正 */
    perspectiveCorrection?: boolean;
    /** 透视校正点 */
    perspectivePoints?: {
        topLeft: Point;
        topRight: Point;
        bottomRight: Point;
        bottomLeft: Point;
    };
}

/**
 * @file 主入口文件
 * @description ID Scanner库的主入口点，提供统一的API和模块导出
 * @module index
 */

/**
 * IDScanner配置选项
 */
interface IDScannerOptions {
    /** 日志级别 */
    logLevel?: LogLevel;
    /** 是否启用身份证识别模块 */
    enableIDCard?: boolean;
    /** 是否启用二维码识别模块 */
    enableQRCode?: boolean;
    /** 是否启用人脸识别模块 */
    enableFace?: boolean;
    /** 身份证模块配置 */
    idCard?: IDCardModuleOptions;
    /** 二维码模块配置 */
    qrCode?: QRCodeModuleOptions;
    /** 人脸识别模块配置 */
    face?: FaceModuleOptions;
}
/**
 * IDScanner类
 * 提供整合的身份证、二维码和人脸识别功能
 */
declare class IDScanner {
    /** 版本号 */
    static readonly VERSION = "1.5.0";
    /** 构建日期 */
    static readonly BUILD_DATE: string;
    /** 模块管理器 */
    private moduleManager;
    /** 是否已经初始化 */
    private initialized;
    /** 日志工具 */
    private logger;
    /**
     * 构造函数
     * @param options 配置选项
     */
    constructor(options?: IDScannerOptions);
    /**
     * 初始化库
     */
    initialize(): Promise<void>;
    /**
     * 获取身份证模块实例
     * @returns 身份证模块
     */
    getIDCardModule(): IDCardModule | undefined;
    /**
     * 获取二维码模块实例
     * @returns 二维码模块
     */
    getQRCodeModule(): QRCodeModule | undefined;
    /**
     * 获取人脸识别模块实例
     * @returns 人脸识别模块
     */
    getFaceModule(): FaceModule | undefined;
    /**
     * 释放所有资源
     */
    dispose(): Promise<void>;
}

export { CameraAccessError, ConsoleLogHandler, DeviceError, FaceComparisonError, FaceDetectionError, FaceModule, IDCardDetectionError, IDCardModule, IDCardType, IDScanner, IDScannerError, InitializationError, InvalidArgumentError, LivenessDetectionError, LogLevel, Logger, MemoryLogHandler, ModuleManager, NotSupportedError, OCRProcessingError, QRCodeModule, QRScanError, RemoteLogHandler, ResourceLoadError, TaggedLogger, IDScanner as default };
export type { DetectionResult, Disposable, FaceComparisonResult, FaceDetectionResult, FaceModuleOptions, IDCardInfo, IDCardModuleOptions, IDCardVerificationResult, IDScannerOptions, ImageProcessingOptions, LogEntry, LogHandler, Module, ModuleOptions, Point, QRCodeModuleOptions, QRCodeResult, Rect };