/**
 * NDLKotenOCR Web版 - メインエントリーポイント
 *
 * このファイルは、NDLKotenOCR Web版のメインエントリーポイントです。
 * 各モジュールを統合し、ブラウザ上でのOCR処理を実行します。
 */
/**
 * NDLKotenOCR クラス
 * 古典籍OCRの全体処理を管理するクラス
 */
interface SimpleInitOptions {
    modelPath?: string;
    modelSize?: 'small' | 'large';
    progressCallback?: (progress: number, message: string) => void;
}
interface ProcessOptions {
    imageName?: string;
    onProgress?: (progress: number, message: string) => void;
}
interface ProcessResult {
    detections: any[];
    xml: string;
    json: any;
    text: string;
}
declare class NDLKotenOCR {
    private layoutDetector;
    private textRecognizer;
    private readingOrderProcessor;
    private outputGenerator;
    initialized: boolean;
    private progressCallback;
    private configPath;
    private static readonly DEFAULT_MODEL_BASE;
    /**
     * 簡単な初期化メソッド（推奨）
     * @param options オプション設定
     */
    init(options?: SimpleInitOptions): Promise<void>;
    /**
     * 詳細な初期化処理（上級者向け）
     * モデルのロードと初期設定を行います
     */
    initialize(layoutModelPath: string, layoutConfig: any | undefined, layoutConfigPath: string | null | undefined, recognizerModelPath: string, recognizerConfig?: any, recognizerConfigPath?: string | null, progressCallback?: ((progress: number, message: string) => void) | null): Promise<void>;
    /**
     * 進捗状況の更新
     */
    private updateProgress;
    /**
     * 画像処理の実行
     */
    process(imageData: ImageData | HTMLImageElement | HTMLCanvasElement, options?: ProcessOptions): Promise<ProcessResult>;
    /**
     * 画像から指定された領域を切り出す
     */
    private cropImage;
}

/**
 * NDLKotenOCR Web版 - レイアウト認識モジュール
 *
 * このファイルは、RTMDetモデルを使用して画像内のテキスト領域を検出するモジュールです。
 * 元のPythonコードのsrc/rtmdet.pyを参考に実装しています。
 */
interface Config {
    inputShape: number[];
    scoreThreshold: number;
    nmsThreshold: number;
    maxDetections: number;
    [key: string]: any;
}
/**
 * RTMDet クラス
 * 画像内のテキスト領域を検出するクラス
 */
declare class RTMDet {
    private modelPath;
    private configPath;
    private config;
    private session;
    private initialized;
    private classNames;
    private progressCallback?;
    /**
     * コンストラクタ
     */
    constructor(modelPath: string, config?: Partial<Config>, configPath?: string | null);
    /**
     * 設定ファイルを読み込む
     */
    loadConfig(configPath?: string | null): Promise<Config>;
    /**
     * 初期化処理
     * 設定を読み込み、ONNXモデルをロードし、推論セッションを作成します
     *
     * @param {string} configPath 設定ファイルのパス（オプション）
     * @param {(progress: number, message: string) => void} progressCallback 進捗コールバック（オプション）
     * @returns {Promise<void>}
     */
    initialize(configPath?: null, progressCallback?: (progress: number, message: string) => void): Promise<void>;
    /**
     * 進捗追跡付きでセッションを作成
     */
    private createSessionWithProgress;
    /**
     * 画像の前処理
     *
     * @param {ImageData|HTMLImageElement|HTMLCanvasElement} imageData 入力画像
     * @returns {Object} 前処理された画像データとメタデータ
     * @private
     */
    preprocess(imageData: ImageData | HTMLImageElement | HTMLCanvasElement): {
        tensor: Float32Array<ArrayBuffer>;
        metadata: {
            originalWidth: number;
            originalHeight: number;
            maxWH: number;
            inputWidth: number;
            inputHeight: number;
        };
    };
    /**
     * 検出結果の後処理
     *
     * @param {Object} outputs モデルの出力結果
     * @param {Object} metadata 前処理で生成されたメタデータ
     * @returns {Array} 検出結果の配列
     * @private
     */
    postprocess(outputs: any, metadata: any): any[];
    /**
     * Non-Maximum Suppression (NMS) の適用
     * 重複する検出結果を除去します
     *
     * @param {Array} detections 検出結果の配列
     * @param {number} threshold IoU閾値
     * @returns {Array} NMS適用後の検出結果
     * @private
     */
    applyNMS(detections: any[], threshold: number): any[];
    /**
     * Intersection over Union (IoU) の計算
     *
     * @param {Array} boxA 1つ目のバウンディングボックス [x1, y1, x2, y2]
     * @param {Array} boxB 2つ目のバウンディングボックス [x1, y1, x2, y2]
     * @returns {number} IoU値 (0-1)
     * @private
     */
    calculateIoU(boxA: number[], boxB: number[]): number;
    /**
     * 画像内のテキスト領域を検出
     *
     * @param {ImageData|HTMLImageElement|HTMLCanvasElement} imageData 入力画像
     * @returns {Promise<Array>} 検出結果の配列
     */
    detect(imageData: ImageData | HTMLImageElement | HTMLCanvasElement): Promise<any[]>;
}

/**
 * NDLKotenOCR Web版 - 文字列認識モジュール
 *
 * このファイルは、PARSeqモデルを使用して検出されたテキスト領域内の文字を認識するモジュールです。
 * 元のPythonコードのsrc/parseq.pyを参考に実装しています。
 */
/**
 * PARSEQ クラス
 * 画像内のテキストを認識するクラス
 */
interface ParseqConfig {
    inputShape: number[];
    charList: string[];
    maxLength: number;
    [key: string]: any;
}
declare class PARSEQ {
    private modelPath;
    private configPath;
    private charListPath;
    private config;
    private session;
    private initialized;
    private progressCallback?;
    /**
     * コンストラクタ
     *
     * @param {string} modelPath モデルファイルのパス
     * @param {Object} config 設定オブジェクト
     * @param {string} configPath 設定ファイルのパス（オプション）
     * @param {string} charListPath 文字リストファイルのパス（オプション）
     */
    constructor(modelPath: string, config?: Partial<ParseqConfig>, configPath?: string | null, charListPath?: string | null);
    /**
     * 設定ファイルを読み込む
     *
     * @param {string} configPath 設定ファイルのパス
     * @returns {Promise<Object>} 読み込まれた設定
     */
    loadConfig(configPath?: null): Promise<ParseqConfig>;
    /**
     * 文字リストファイルを読み込む
     *
     * @param {string} charListPath 文字リストファイルのパス
     * @returns {Promise<Array<string>>} 読み込まれた文字リスト
     */
    loadCharList(charListPath?: null): Promise<string[]>;
    /**
     * 初期化処理
     * 設定を読み込み、ONNXモデルをロードし、推論セッションを作成します
     *
     * @param {string} configPath 設定ファイルのパス（オプション）
     * @param {string} charListPath 文字リストファイルのパス（オプション）
     * @param {(progress: number, message: string) => void} progressCallback 進捗コールバック（オプション）
     * @returns {Promise<void>}
     */
    initialize(configPath?: null, charListPath?: null, progressCallback?: (progress: number, message: string) => void): Promise<void>;
    /**
     * 進捗追跡付きでセッションを作成
     */
    private createSessionWithProgress;
    /**
     * 画像の前処理
     *
     * @param {ImageData|HTMLImageElement|HTMLCanvasElement} imageData 入力画像
     * @returns {Float32Array} 前処理された画像データ
     * @private
     */
    preprocess(imageData: ImageData | HTMLImageElement | HTMLCanvasElement): Float32Array<ArrayBuffer>;
    /**
     * 認識結果の後処理
     *
     * @param {Object} outputs モデルの出力結果
     * @returns {string} 認識されたテキスト
     * @private
     */
    postprocess(outputs: any): string;
    /**
     * 画像内のテキストを認識
     *
     * @param {ImageData|HTMLImageElement|HTMLCanvasElement} imageData 入力画像
     * @returns {Promise<string>} 認識されたテキスト
     */
    read(imageData: ImageData | HTMLImageElement | HTMLCanvasElement): Promise<string>;
}

/**
 * NDLKotenOCR Web版 - 読み順処理モジュール
 *
 * このファイルは、検出されたテキスト領域を適切な読み順に整列するモジュールです。
 * 元のPythonコードのsrc/reading_order/xy_cut/eval.pyを参考に実装しています。
 */
/**
 * 設定インターface
 */
interface ReadingOrderConfig$1 {
    verticalMode: boolean;
}
/**
 * 検出結果のインターface
 */
interface Detection$1 {
    box: [number, number, number, number];
    confidence?: number;
    text?: string;
    id?: number;
    center?: {
        x: number;
        y: number;
    };
}
/**
 * 設定ファイルを読み込む
 *
 * @param {string} configPath 設定ファイルのパス
 * @returns {Promise<ReadingOrderConfig>} 読み込まれた設定
 */
declare function loadConfig$1(configPath: string | null): Promise<ReadingOrderConfig$1>;
/**
 * 読み順処理クラス
 * 検出されたテキスト領域を適切な読み順に整列するクラス
 */
declare class ReadingOrderProcessor {
    private config;
    /**
     * コンストラクタ
     *
     * @param {ReadingOrderConfig} config 設定オブジェクト
     */
    constructor(config?: ReadingOrderConfig$1 | null);
    /**
     * XY-cut法による読み順の決定
     *
     * @param {Detection[]} detections 検出結果の配列
     * @param {number} imageWidth 画像の幅
     * @param {number} imageHeight 画像の高さ
     * @returns {Detection[]} 読み順に整列された検出結果
     */
    process(detections: Detection$1[], imageWidth: number, imageHeight: number): Detection$1[];
    /**
     * XY-cut法の実装
     *
     * @param {Detection[]} boxes バウンディングボックスの配列
     * @param {number} imageWidth 画像の幅
     * @param {number} imageHeight 画像の高さ
     * @returns {Detection[]} 読み順に整列されたボックス
     * @private
     */
    private _xycut;
    /**
     * 縦方向の分割を試みる
     *
     * @param {Detection[]} boxes バウンディングボックスの配列
     * @param {number} imageWidth 画像の幅
     * @param {number} imageHeight 画像の高さ
     * @returns {Detection[][]} 分割されたグループの配列
     * @private
     */
    private _trySplitVertical;
    /**
     * 横方向の分割を試みる
     *
     * @param {Detection[]} boxes バウンディングボックスの配列
     * @param {number} imageWidth 画像の幅
     * @param {number} imageHeight 画像の高さ
     * @returns {Detection[][]} 分割されたグループの配列
     * @private
     */
    private _trySplitHorizontal;
    /**
     * ボックスを位置でソート
     *
     * @param {Detection[]} boxes バウンディングボックスの配列
     * @returns {Detection[]} ソートされたボックス
     * @private
     */
    private _sortBoxesByPosition;
}

/**
 * NDLKotenOCR Web版 - 出力生成モジュール
 *
 * このファイルは、OCR結果を様々な形式（XML, JSON, TXT）で出力するモジュールです。
 * 元のPythonコードのsrc/ndl_parser.pyを参考に実装しています。
 */
/**
 * 設定ファイルを読み込む
 *
 * @param {string} configPath 設定ファイルのパス
 * @returns {Promise<Object>} 読み込まれた設定
 */
declare function loadConfig(configPath: string | null): Promise<{
    xml: {
        includeConfidence: boolean;
        prettyPrint: boolean;
        encoding: string;
    };
    json: {
        includeConfidence: boolean;
        prettyPrint: boolean;
        includeMetadata: boolean;
    };
    txt: {
        separator: string;
        includeBoundingBox: boolean;
    };
}>;
/**
 * 出力生成クラス
 * OCR結果を様々な形式で出力するクラス
 */
interface TextElement {
    id: number;
    x: number;
    y: number;
    width: number;
    height: number;
    text: string;
    confidence?: number;
}
interface JSONOutput {
    document: {
        image: {
            name: string;
            width: number;
            height: number;
            text: TextElement[];
        };
    };
    metadata?: {
        timestamp: string;
        version: string;
        engine: string;
        fileCount?: number;
    };
}
interface OutputConfig$1 {
    xml: {
        includeConfidence: boolean;
        prettyPrint: boolean;
        encoding: string;
    };
    json: {
        includeConfidence: boolean;
        prettyPrint: boolean;
        includeMetadata: boolean;
    };
    txt: {
        separator: string;
        includeBoundingBox: boolean;
    };
}
declare class OutputGenerator {
    private config;
    /**
     * コンストラクタ
     *
     * @param {Object} config 設定オブジェクト
     */
    constructor(config?: OutputConfig$1 | null);
    /**
     * XML形式で出力を生成
     *
     * @param {Array} detections 検出結果の配列
     * @param {number} imageWidth 画像の幅
     * @param {number} imageHeight 画像の高さ
     * @param {string} imageName 画像名
     * @returns {string} XML形式の出力
     */
    generateXML(detections: any[], _imageWidth: number, _imageHeight: number, _imageName?: string, imageUrl?: string | null): string;
    /**
     * JSON形式で出力を生成
     *
     * @param {Array} detections 検出結果の配列
     * @param {number} imageWidth 画像の幅
     * @param {number} imageHeight 画像の高さ
     * @param {string} imageName 画像名
     * @returns {Object} JSON形式の出力
     */
    generateJSON(detections: any[], imageWidth: number, imageHeight: number, imageName?: string): JSONOutput;
    /**
     * テキスト形式で出力を生成
     *
     * @param {Array} detections 検出結果の配列
     * @returns {string} テキスト形式の出力
     */
    generateTXT(detections: any[]): string;
    /**
     * 全ての検出結果を統合したXML形式で出力を生成
     *
     * @param {Array} resultsArray 複数の処理結果の配列
     * @param {Array} imageNames 画像名の配列
     * @returns {string} 統合されたXML形式の出力
     */
    generateCombinedXML(resultsArray: any[], imageNames?: string[]): string;
    /**
     * 全ての検出結果を統合したJSON形式で出力を生成
     *
     * @param {Array} resultsArray 複数の処理結果の配列
     * @param {Array} imageNames 画像名の配列
     * @returns {Object} 統合されたJSON形式の出力
     */
    generateCombinedJSON(resultsArray: any[], imageNames?: string[]): any;
    /**
     * 全ての検出結果を統合したテキスト形式で出力を生成
     *
     * @param {Array} resultsArray 複数の処理結果の配列
     * @param {Array} imageNames 画像名の配列
     * @returns {string} 統合されたテキスト形式の出力
     */
    generateCombinedTXT(resultsArray: any[], imageNames?: string[]): string;
    /**
     * XMLで使用される特殊文字をエスケープ
     *
     * @param {string} str エスケープする文字列
     * @returns {string} エスケープされた文字列
     * @private
     */
    _escapeXml(str: string): string;
}

/**
 * Web Worker版のNDL Koten OCR
 * メインスレッドをブロックせずにOCR処理を実行できます
 */
declare class NDLKotenOCRWorker {
    private worker;
    private messageId;
    private pendingMessages;
    private progressCallbacks;
    /**
     * Workerを初期化します
     * @param workerUrl - Worker スクリプトのURL（省略時は自動的に生成）
     */
    constructor(workerUrl?: string | URL);
    private setupWorkerListeners;
    private postMessage;
    /**
     * OCRエンジンを初期化します
     * @param options - 初期化オプション
     */
    init(options?: SimpleInitOptions): Promise<void>;
    /**
     * 画像からテキストを認識します
     * @param imageData - 処理対象の画像データ（ImageData, HTMLImageElement, HTMLCanvasElement）
     * @param options - 処理オプション
     * @returns OCR処理結果
     */
    process(imageData: ImageData | HTMLImageElement | HTMLCanvasElement, options?: ProcessOptions): Promise<ProcessResult>;
    /**
     * Workerを終了してリソースを解放します
     */
    terminate(): void;
    /**
     * Workerが初期化されているかチェックします
     */
    isInitialized(): boolean;
}

/**
 * TEI/XML Converter
 * OCR結果をTEI/XML形式に変換するユーティリティ
 */
interface TEIConversionData {
    title?: string;
    sourceUrl?: string;
    results?: any[];
    xml?: string;
    json?: any;
}
declare class TEIConverter {
    /**
     * Static method to convert OCR results to TEI format
     * @deprecated Use instance method convertOCRResults instead
     */
    static convert(data: TEIConversionData): string;
    /**
     * OCR結果の配列を直接TEI/XMLに変換する便利メソッド
     */
    static convertFromOCRResults(ocrResults: Array<{
        text?: string;
        json?: any;
        imageUrl?: string;
        imageInfo?: any;
    }>, options?: {
        title?: string;
        manifestUrl?: string;
    }): string;
    /**
     * Convert OCR results to TEI/XML format
     */
    convertOCRResults(data: TEIConversionData): string;
    private combineTEIResults;
    private _escapeXml;
    private generateXML;
}

/**
 * IIIF Manifest Processor
 * IIIFマニフェストからの画像取得と処理
 */

interface IIIFImageInfo {
    canvasId: string;
    imageUrl: string;
    thumbnailUrl: string;
    label: string;
    index: number;
}
interface IIIFProcessOptions extends ProcessOptions {
    maxImages?: number;
    downloadImages?: boolean;
    onImageProgress?: (imageIndex: number, progress: number, message: string) => void;
}
declare class IIIFProcessor {
    private ocrEngine;
    private teiConverter;
    constructor(ocrEngine?: NDLKotenOCR);
    /**
     * IIIFマニフェストから画像リストを取得する静的メソッド
     */
    static getImagesFromManifest(manifestUrl: string): Promise<IIIFImageInfo[]>;
    /**
     * IIIFマニフェストURLから画像を取得してOCR処理を実行
     */
    processManifestUrl(manifestUrl: string, options?: IIIFProcessOptions): Promise<{
        results: ProcessResult[];
        teiXml: string;
        manifest: any;
    }>;
    /**
     * マニフェストを取得
     */
    fetchManifest(url: string): Promise<any>;
    /**
     * マニフェストから画像情報を抽出
     */
    extractImages(manifest: any): IIIFImageInfo[];
    /**
     * 画像を取得してImageDataに変換
     */
    private fetchImage;
    /**
     * Presentation API v2からv3への簡易変換
     */
    private convertV2ToV3;
    /**
     * ラベルの変換（文字列または多言語オブジェクト）
     */
    private convertLabel;
    /**
     * マニフェストタイトルの取得
     */
    private getManifestTitle;
    /**
     * キャンバスラベルの取得
     */
    private getCanvasLabel;
}

interface Detection {
    box: number[];
    confidence: number;
    class: number;
}
interface RecognizedDetection extends Detection {
    text: string;
}
interface OCRResult {
    detections: RecognizedDetection[];
    xml: string;
    json: string;
    text: string;
}
interface LayoutConfig {
    model_path?: string;
    confidence_threshold?: number;
    iou_threshold?: number;
}
interface RecognizerConfig {
    model_path?: string;
    charset_path?: string;
    max_length?: number;
}
interface ReadingOrderConfig {
    direction?: 'vertical' | 'horizontal';
    line_clustering_threshold?: number;
}
interface OutputConfig {
    format?: 'xml' | 'json' | 'text' | 'all';
    include_confidence?: boolean;
}

export { type Detection, type IIIFImageInfo, type IIIFProcessOptions, IIIFProcessor, type LayoutConfig, NDLKotenOCR, NDLKotenOCRWorker, type OCRResult, type OutputConfig, OutputGenerator, PARSEQ, type ProcessOptions, type ProcessResult, RTMDet, type ReadingOrderConfig, ReadingOrderProcessor, type RecognizedDetection, type RecognizerConfig, type SimpleInitOptions, type TEIConversionData, TEIConverter, loadConfig as loadOutputConfig, loadConfig$1 as loadReadingOrderConfig };