import { RnExecutorchError } from '../errors/errorUtils';
import { LabelEnum, Triple, ResourceSource, PixelData, Frame } from './common';
import { CocoLabel } from '../constants/commonVision';
export { CocoLabel };
/**
 * Represents a bounding box for a detected object in an image.
 * @category Types
 * @property {number} x1 - The x-coordinate of the top-left corner of the bounding box.
 * @property {number} y1 - The y-coordinate of the top-left corner of the bounding box.
 * @property {number} x2 - The x-coordinate of the bottom-right corner of the bounding box.
 * @property {number} y2 - The y-coordinate of the bottom-right corner of the bounding box.
 */
export interface Bbox {
    x1: number;
    x2: number;
    y1: number;
    y2: number;
}
/**
 * Represents a detected object within an image, including its bounding box, label, and confidence score.
 * @category Types
 * @typeParam L - The label enum type for the detected object. Defaults to {@link CocoLabel}.
 * @property {Bbox} bbox - The bounding box of the detected object, defined by its top-left (x1, y1) and bottom-right (x2, y2) coordinates.
 * @property {keyof L} label - The class label of the detected object.
 * @property {number} score - The confidence score of the detection, typically ranging from 0 to 1.
 */
export interface Detection<L extends LabelEnum = typeof CocoLabel> {
    bbox: Bbox;
    label: keyof L;
    score: number;
}
/**
 * Options for configuring object detection inference.
 * @category Types
 * @typeParam L - The label enum type for filtering classes of interest.
 * @property {number} [detectionThreshold] - Minimum confidence score for detections (0-1). Defaults to model-specific value.
 * @property {number} [iouThreshold] - IoU threshold for non-maximum suppression (0-1). Defaults to model-specific value.
 * @property {number} [inputSize] - Input size for multi-method models (e.g., 384, 512, 640 for YOLO). Required for YOLO models if not using default.
 * @property {(keyof L)[]} [classesOfInterest] - Optional array of class labels to filter detections. Only detections matching these classes will be returned.
 */
export interface ObjectDetectionOptions<L extends LabelEnum> {
    detectionThreshold?: number;
    iouThreshold?: number;
    inputSize?: number;
    classesOfInterest?: (keyof L)[];
}
/**
 * Per-model config for {@link ObjectDetectionModule.fromModelName}.
 * Each model name maps to its required fields.
 * @category Types
 */
export type ObjectDetectionModelSources = {
    modelName: 'ssdlite-320-mobilenet-v3-large';
    modelSource: ResourceSource;
} | {
    modelName: 'rf-detr-nano';
    modelSource: ResourceSource;
} | {
    modelName: 'yolo26n';
    modelSource: ResourceSource;
} | {
    modelName: 'yolo26s';
    modelSource: ResourceSource;
} | {
    modelName: 'yolo26m';
    modelSource: ResourceSource;
} | {
    modelName: 'yolo26l';
    modelSource: ResourceSource;
} | {
    modelName: 'yolo26x';
    modelSource: ResourceSource;
};
/**
 * Union of all built-in object detection model names.
 * @category Types
 */
export type ObjectDetectionModelName = ObjectDetectionModelSources['modelName'];
/**
 * Configuration for a custom object detection model.
 * @category Types
 * @typeParam T - The label enum type for the model.
 * @property {T} labelMap - The label mapping for the model.
 * @property {object} [preprocessorConfig] - Optional preprocessing configuration with normalization parameters.
 * @property {number} [defaultDetectionThreshold] - Default detection confidence threshold (0-1).
 * @property {number} [defaultIouThreshold] - Default IoU threshold for non-maximum suppression (0-1).
 * @property {readonly number[]} [availableInputSizes] - For multi-method models, the available input sizes (e.g., [384, 512, 640]).
 * @property {number} [defaultInputSize] - For multi-method models, the default input size to use.
 */
export type ObjectDetectionConfig<T extends LabelEnum> = {
    labelMap: T;
    preprocessorConfig?: {
        normMean?: Triple<number>;
        normStd?: Triple<number>;
    };
    defaultDetectionThreshold?: number;
    defaultIouThreshold?: number;
} & ({
    availableInputSizes: readonly number[];
    defaultInputSize: number;
} | {
    availableInputSizes?: undefined;
    defaultInputSize?: undefined;
});
/**
 * Props for the `useObjectDetection` hook.
 * @typeParam C - A {@link ObjectDetectionModelSources} config specifying which built-in model to load.
 * @category Types
 * @property model - The model config containing `modelName` and `modelSource`.
 * @property {boolean} [preventLoad] - Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
 */
export interface ObjectDetectionProps<C extends ObjectDetectionModelSources> {
    model: C;
    preventLoad?: boolean;
}
/**
 * Return type for the `useObjectDetection` hook.
 * Manages the state and operations for Computer Vision object detection tasks.
 * @typeParam L - The {@link LabelEnum} representing the model's class labels.
 * @category Types
 */
export interface ObjectDetectionType<L extends LabelEnum> {
    /**
     * Contains the error object if the model failed to load, download, or encountered a runtime error during detection.
     */
    error: RnExecutorchError | null;
    /**
     * Indicates whether the object detection model is loaded and ready to process images.
     */
    isReady: boolean;
    /**
     * Indicates whether the model is currently processing an image.
     */
    isGenerating: boolean;
    /**
     * Represents the download progress of the model binary as a value between 0 and 1.
     */
    downloadProgress: number;
    /**
     * Executes the model's forward pass with automatic input type detection.
     * @param input - Image source (string path/URI or PixelData object)
     * @param options - Optional configuration for detection inference
     * @returns A Promise that resolves to an array of `Detection` objects.
     * @throws {RnExecutorchError} If the model is not loaded or is currently processing another image.
     * @example
     * ```typescript
     * // String path with options
     * const detections1 = await model.forward('file:///path/to/image.jpg', {
     *   detectionThreshold: 0.7,
     *   inputSize: 640,  // For YOLO models
     *   classesOfInterest: ['PERSON', 'CAR']
     * });
     *
     * // Pixel data
     * const detections2 = await model.forward({
     *   dataPtr: new Uint8Array(rgbPixels),
     *   sizes: [480, 640, 3],
     *   scalarType: ScalarType.BYTE
     * }, { detectionThreshold: 0.5 });
     * ```
     */
    forward: (input: string | PixelData, options?: ObjectDetectionOptions<L>) => Promise<Detection<L>[]>;
    /**
     * Returns the available input sizes for multi-method models (e.g., YOLO).
     * Returns undefined for single-method models (e.g., RF-DETR, SSDLite).
     * @returns Array of available input sizes or undefined
     * @example
     * ```typescript
     * const sizes = model.getAvailableInputSizes(); // [384, 512, 640] for YOLO models
     * ```
     */
    getAvailableInputSizes: () => readonly number[] | undefined;
    /**
     * Synchronous worklet function for real-time VisionCamera frame processing.
     * Automatically handles native buffer extraction and cleanup.
     *
     * **Use this for VisionCamera frame processing in worklets.**
     * For async processing, use `forward()` instead.
     *
     * Available after model is loaded (`isReady: true`).
     * @param frame - VisionCamera Frame object
     * @param isFrontCamera - Whether the front camera is active, used for mirroring corrections.
     * @param options - Optional configuration for detection inference
     * @returns Array of Detection objects representing detected items in the frame.
     */
    runOnFrame: ((frame: Frame, isFrontCamera: boolean, options?: ObjectDetectionOptions<L>) => Detection<L>[]) | null;
}
//# sourceMappingURL=objectDetection.d.ts.map