import { EventEmitter } from 'node:events';

interface ProgressEvent {
    stage: number;
    iteration: number;
    expected: number;
}
interface DataErrorEvent {
    offset: number;
    file: string;
}
interface ExifTagEvent {
    tag: number;
    type: number;
    length: number;
    order: number;
}
interface MakerNoteEvent {
    tag: number;
    type: number;
    length: number;
    order: number;
}

interface MetadataSnapshot {
    make?: string;
    model?: string;
    software?: string;
    width: number;
    height: number;
    rawWidth: number;
    rawHeight: number;
    colors: number;
    filters: number;
    iso?: number;
    shutterSpeed?: number;
    aperture?: number;
    focalLength?: number;
    timestamp?: number;
}
interface ImageSizeSnapshot {
    width: number;
    height: number;
    rawWidth: number;
    rawHeight: number;
    topMargin: number;
    leftMargin: number;
    iWidth: number;
    iHeight: number;
}
interface AdvancedMetadataSnapshot {
    normalizedMake?: string;
    normalizedModel?: string;
    rawCount: number;
    dngVersion: number;
    is_foveon: number;
    colorMatrix: [number[], number[], number[], number[]];
    camMul: [number, number, number, number];
    preMul: [number, number, number, number];
    blackLevel: number;
    dataMaximum: number;
    whiteLevel: number;
}
interface LensInfoSnapshot {
    lensName?: string;
    lensMake?: string;
    lensSerial?: string;
    internalLensSerial?: string;
    minFocal?: number;
    maxFocal?: number;
    maxAp4MinFocal?: number;
    maxAp4MaxFocal?: number;
    exifMaxAp?: number;
    focalLengthIn35mmFormat?: number;
}
interface ColorInfoSnapshot {
    colors: number;
    filters: number;
    blackLevel: number;
    dataMaximum: number;
    whiteLevel: number;
    profileLength?: number;
    rgbCam: [number[], number[], number[]];
    camMul: [number, number, number, number];
}
interface OutputParamsSnapshot {
    greybox: [number, number, number, number];
    cropbox: [number, number, number, number];
    aber: [number, number, number, number];
    gamma: [number, number, number, number, number, number];
    user_mul: [number, number, number, number];
    bright: number;
    threshold: number;
    half_size: boolean;
    four_color_rgb: boolean;
    highlight: number;
    use_auto_wb: boolean;
    use_camera_wb: boolean;
    use_camera_matrix: number;
    output_color: number;
    output_bps: number;
    output_tiff: boolean;
    output_flags: number;
    user_flip: number;
    user_qual: number;
    user_black: number;
    user_cblack: [number, number, number, number];
    user_sat: number;
    med_passes: number;
    auto_bright_thr: number;
    adjust_maximum_thr: number;
    no_auto_bright: boolean;
    use_fuji_rotate: boolean;
    use_p1_correction: boolean;
    green_matching: boolean;
    dcb_iterations: number;
    dcb_enhance_fl: boolean;
    fbdd_noiserd: number;
    exp_correc: boolean;
    exp_shift: number;
    exp_preser: number;
    no_auto_scale: boolean;
    no_interpolation: boolean;
    output_profile: string | null;
    camera_profile: string | null;
    bad_pixels: string | null;
    dark_frame: string | null;
}
interface LibRawImageDataSnapshot {
    metadata: MetadataSnapshot;
    sizes: ImageSizeSnapshot;
    advanced: AdvancedMetadataSnapshot;
    lens: LensInfoSnapshot;
    color: ColorInfoSnapshot;
    params: OutputParamsSnapshot;
}

interface LibRawOptions {
    flags?: number;
}
interface OperationOptions {
    signal?: AbortSignal;
}
type ProcessorState = "idle" | "opening" | "opened" | "unpacked" | "processed" | "closing" | "closed" | "error";
interface BayerDescriptor {
    width: number;
    height: number;
    leftMargin?: number;
    topMargin?: number;
    rightMargin?: number;
    bottomMargin?: number;
    procFlags?: number;
    bayerPattern?: number;
    unusedBits?: number;
    otherFlags?: number;
    blackLevel?: number;
}
interface ProcessedImage {
    data: Buffer;
    type: number;
    height: number;
    width: number;
    colors: number;
    bits: number;
    dataSize: number;
}
interface MemoryImageFormat {
    width: number;
    height: number;
    colors: number;
    bps: number;
}
interface DecoderInfo {
    decoder_name: string;
    decoder_flags: number;
}
interface EncodedImageResult {
    data: Buffer;
    format: "jpeg" | "png" | "tiff" | "webp" | "avif" | "ppm";
    width: number;
    height: number;
    channels: number;
    size: number;
    processingTimeMs: number;
    source: "processed" | "embedded-thumbnail";
}
type JPEGUsage = "web" | "print" | "archive";
interface OptimalJPEGSettings {
    recommended: {
        quality: number;
        progressive: boolean;
        mozjpeg: boolean;
        chromaSubsampling: "4:2:0" | "4:4:4";
        optimizeCoding: boolean;
        trellisQuantisation: boolean;
        optimizeScans: boolean;
        reasoning: string[];
    };
    imageAnalysis: {
        dimensions: {
            width: number;
            height: number;
            area: number;
        };
        category: "high-resolution" | "medium-resolution" | "low-resolution";
        camera: {
            make?: string;
            model?: string;
        };
    };
}

interface RenderOptions extends OperationOptions {
    width?: number;
    height?: number;
    quality?: number;
    compressionLevel?: number;
    effort?: number;
    progressive?: boolean;
    mozjpeg?: boolean;
    chromaSubsampling?: string;
    optimizeCoding?: boolean;
    trellisQuantisation?: boolean;
    optimizeScans?: boolean;
}

interface LibRawErrorOptions {
    code: string;
    operation: string;
    librawCode?: number | null;
    state: ProcessorState;
    cause?: unknown;
}
declare class LibRawError extends Error {
    readonly code: string;
    readonly operation: string;
    readonly librawCode: number | null;
    readonly state: ProcessorState;
    readonly cause: unknown;
    constructor(message: string, options: LibRawErrorOptions);
}
declare function normalizeError(error: unknown, operation: string, state: ProcessorState): LibRawError;

declare class LibRaw extends EventEmitter {
    readonly flags: number;
    private readonly worker;
    private readonly cancellationBuffer;
    private readonly cancellation;
    private readonly pending;
    private nextRequestId;
    private tail;
    private closePromise?;
    private closeRequested;
    private workerFailure?;
    private _state;
    constructor(options?: LibRawOptions);
    get state(): ProcessorState;
    private request;
    private enqueue;
    openFile(file: string, options?: OperationOptions): Promise<void>;
    openBuffer(input: Uint8Array, options?: OperationOptions): Promise<void>;
    openBayer(input: Uint8Array, descriptor: BayerDescriptor, options?: OperationOptions): Promise<void>;
    loadFile(file: string, options?: OperationOptions): Promise<void>;
    loadBuffer(input: Uint8Array, options?: OperationOptions): Promise<void>;
    loadBayerData(file: string, descriptor: BayerDescriptor, options?: OperationOptions): Promise<void>;
    recycle(options?: OperationOptions): Promise<void>;
    close(): Promise<void>;
    getImgData(options?: OperationOptions): Promise<LibRawImageDataSnapshot>;
    unpack(options?: OperationOptions): Promise<void>;
    unpackThumb(options?: OperationOptions): Promise<void>;
    unpackThumbEx(index: number, options?: OperationOptions): Promise<void>;
    dcrawProcess(options?: OperationOptions): Promise<void>;
    processImage(options?: OperationOptions): Promise<void>;
    dcrawMakeMemImage(options?: OperationOptions): Promise<ProcessedImage>;
    dcrawMakeMemThumb(options?: OperationOptions): Promise<ProcessedImage>;
    createMemoryImage(options?: OperationOptions): Promise<ProcessedImage>;
    createMemoryThumbnail(options?: OperationOptions): Promise<ProcessedImage>;
    setCancelFlag(): void;
    clearCancelFlag(): void;
    private runWorkflow;
    private render;
    private encodeImage;
    createJPEGBuffer(options?: RenderOptions): Promise<EncodedImageResult>;
    createPNGBuffer(options?: RenderOptions): Promise<EncodedImageResult>;
    createTIFFBuffer(options?: RenderOptions): Promise<EncodedImageResult>;
    createWebPBuffer(options?: RenderOptions): Promise<EncodedImageResult>;
    createAVIFBuffer(options?: RenderOptions): Promise<EncodedImageResult>;
    createThumbnailJPEGBuffer(options?: RenderOptions): Promise<EncodedImageResult>;
    createPPMBuffer(options?: OperationOptions): Promise<EncodedImageResult>;
    convertToJPEG(outputPath: string, options?: RenderOptions): Promise<EncodedImageResult>;
    convertToJPEGFast(outputPath: string, options?: RenderOptions): Promise<EncodedImageResult>;
    private writeJPEG;
    convertToJPEGMultiSize(baseOutputPath: string, options?: RenderOptions & {
        sizes?: Array<RenderOptions & {
            name: string;
        }>;
    }): Promise<Record<string, EncodedImageResult>>;
    batchConvertToJPEG(inputPaths: string[], outputDirectory: string, options?: RenderOptions & {
        maxConcurrency?: number;
    }): Promise<EncodedImageResult[]>;
    processRawThumbnail(options: {
        filePath: string;
        format: "jpeg" | "png" | "webp";
        maxSize: number;
        quality?: number;
        compressionLevel?: number;
        tryEmbedded?: boolean;
        signal?: AbortSignal;
    }): Promise<EncodedImageResult>;
    getOptimalJPEGSettings(options?: {
        usage?: JPEGUsage;
    }): Promise<OptimalJPEGSettings>;
    static batchConvertToJPEGParallel(inputPaths: string[], outputDirectory: string, options?: RenderOptions & {
        maxConcurrency?: number;
    }): Promise<EncodedImageResult[]>;
    static version(): string;
    static versionNumber(): number;
    static capabilities(): number;
    static cameraList(): readonly string[];
    static cameraCount(): number;
    static strError(code: number): string;
    static strProgress(progress: number): string;
    static cameraMakerIndexToMaker(index: number): string | null;
    static simplifyMakeModel(makerIndex: number, make: string, model: string): {
        makerIndex: number;
        make: string;
        model: string;
    };
    static powfLimited(base: number, exponent: number, limit: number): number;
    static powf64Limited(base: number, exponent: number): number;
    static readBigEndianUnsigned(length: number, input: Uint8Array): number;
    version(): string;
    versionNumber(): number;
    static getVersion(): string;
    static getCapabilities(): number;
    static getCameraList(): readonly string[];
    static getCameraCount(): number;
}
interface LibRaw {
    on(event: "progress", listener: (event: ProgressEvent) => void): this;
    on(event: "dataError", listener: (event: DataErrorEvent) => void): this;
    on(event: "exifTag", listener: (event: ExifTagEvent) => void): this;
    on(event: "makerNote", listener: (event: MakerNoteEvent) => void): this;
    on(event: string | symbol, listener: (...args: any[]) => void): this;
    errorCount(options?: OperationOptions): Promise<number>;
    recycleDatastream(options?: OperationOptions): Promise<void>;
    subtractBlack(options?: OperationOptions): Promise<void>;
    subtractBlackInternal(options?: OperationOptions): Promise<void>;
    raw2Image(options?: OperationOptions): Promise<void>;
    raw2ImageEx(subtractBlack?: boolean, options?: OperationOptions): Promise<void>;
    raw2ImageStart(options?: OperationOptions): Promise<void>;
    freeImage(options?: OperationOptions): Promise<void>;
    adjustMaximum(options?: OperationOptions): Promise<void>;
    adjustSizesInfoOnly(options?: OperationOptions): Promise<void>;
    adjustToRawInsetCrop(mask: number, maxCrop?: number, options?: OperationOptions): Promise<void>;
    setMakeFromIndex(index: number, options?: OperationOptions): Promise<void>;
    convertFloatToInt(min?: number, max?: number, target?: number, options?: OperationOptions): Promise<void>;
    dcrawPpmTiffWriter(file: string, options?: OperationOptions): Promise<void>;
    dcrawThumbWriter(file: string, options?: OperationOptions): Promise<void>;
    getMemImageFormat(options?: OperationOptions): Promise<MemoryImageFormat>;
    copyMemImage(destination: Buffer, stride: number, bgr?: boolean, options?: OperationOptions): Promise<void>;
    colorAt(row: number, column: number, options?: OperationOptions): Promise<number>;
    filterColorAt(row: number, column: number, options?: OperationOptions): Promise<number>;
    fcol(row: number, column: number, options?: OperationOptions): Promise<number>;
    unpackFunctionName(options?: OperationOptions): Promise<string>;
    getDecoderInfo(options?: OperationOptions): Promise<DecoderInfo>;
    phaseOneSubtractBlack(source: Buffer, options?: OperationOptions): Promise<Buffer>;
    phaseOneCorrect(options?: OperationOptions): Promise<void>;
    adobeCoeff(makerIndex: number, model: string, internalOnly?: boolean, options?: OperationOptions): Promise<void>;
    thumbOk(maxSize?: number, options?: OperationOptions): Promise<number>;
    isFujiRotated(options?: OperationOptions): Promise<boolean>;
    isSraw(options?: OperationOptions): Promise<boolean>;
    srawMidpoint(options?: OperationOptions): Promise<number>;
    isNikonSraw(options?: OperationOptions): Promise<boolean>;
    isCoolscanNef(options?: OperationOptions): Promise<boolean>;
    isJpegThumb(options?: OperationOptions): Promise<boolean>;
    isFloatingPoint(options?: OperationOptions): Promise<boolean>;
    haveFpData(options?: OperationOptions): Promise<boolean>;
    getMetadata(options?: OperationOptions): Promise<LibRawImageDataSnapshot["metadata"]>;
    getImageSize(options?: OperationOptions): Promise<LibRawImageDataSnapshot["sizes"]>;
    getAdvancedMetadata(options?: OperationOptions): Promise<LibRawImageDataSnapshot["advanced"]>;
    getLensInfo(options?: OperationOptions): Promise<LibRawImageDataSnapshot["lens"]>;
    getColorInfo(options?: OperationOptions): Promise<LibRawImageDataSnapshot["color"]>;
    setOutputParams(params: Partial<LibRawImageDataSnapshot["params"]>, options?: OperationOptions): Promise<void>;
    getOutputParams(options?: OperationOptions): Promise<LibRawImageDataSnapshot["params"]>;
    getLastError(options?: OperationOptions): Promise<unknown>;
    strerror(code: number, options?: OperationOptions): Promise<string>;
    writePPM(file: string, options?: OperationOptions): Promise<void>;
    writeTIFF(file: string, options?: OperationOptions): Promise<void>;
    writeThumbnail(file: string, options?: OperationOptions): Promise<void>;
    getRawImageBuffer(options?: OperationOptions): Promise<Buffer>;
}

export { type AdvancedMetadataSnapshot, type BayerDescriptor, type ColorInfoSnapshot, type DataErrorEvent, type DecoderInfo, type EncodedImageResult, type ExifTagEvent, type ImageSizeSnapshot, type JPEGUsage, type LensInfoSnapshot, LibRaw, LibRawError, type LibRawErrorOptions, type LibRawImageDataSnapshot, type LibRawOptions, type MakerNoteEvent, type MemoryImageFormat, type MetadataSnapshot, type OperationOptions, type OptimalJPEGSettings, type OutputParamsSnapshot, type ProcessedImage, type ProcessorState, type ProgressEvent, LibRaw as default, normalizeError };