import * as react from 'react';
import { ReactNode, ForwardedRef } from 'react';
import Webcam from 'react-webcam';
import * as react_jsx_runtime from 'react/jsx-runtime';

interface RoboflowWebcamProps {
    children?: ReactNode;
    mirrored?: boolean;
    onInitialized?: () => void;
    onSizeChange?: (width: number, height: number) => void;
}

declare const RoboflowWebcam: react.ForwardRefExoticComponent<RoboflowWebcamProps & react.RefAttributes<Webcam>>;

interface RoboflowAuthParams {
    publishable_key: string;
}
interface RoboflowLoadParams {
    model: string;
    version: string;
    onMetadata?: (m: RoboflowProject) => void;
}
interface RoboflowModule {
    VERSION: string;
    auth: (authParams: RoboflowAuthParams) => RoboflowModule;
    load: (loadParams: RoboflowLoadParams) => Promise<RoboflowModel>;
    tf: any;
}
interface RoboflowProject {
    type: string;
    name: string;
    annotation: string;
    classes: string[];
    size: number;
    icon: string;
}
interface RoboflowModelConfiguration {
    threshold: number;
    overlap?: number;
    nms_threshold?: number;
    max_objects: number;
}
interface RoboflowModelMetadata {
    threshold: number;
    name: string;
    type: string;
    classes: string[];
    annotation: string;
    size: number;
}
interface RoboflowModel {
    configure: (configuration: RoboflowModelConfiguration) => void;
    detect: (source: HTMLImageElement | HTMLVideoElement | HTMLCanvasElement) => Promise<RoboflowObjectDetection[]>;
    getConfiguration: () => RoboflowModelConfiguration;
    getMetadata: () => RoboflowModelMetadata;
    teardown: () => void;
}
interface RoboflowBoundingBox {
    class?: string;
    color?: string;
    confidence?: number;
    height: number;
    width: number;
    x: number;
    y: number;
}
interface RoboflowObjectDetection {
    bbox: RoboflowBoundingBox;
    class: string;
    color: string;
    confidence: number;
}

interface RoboflowApi {
    load: (loadParams: RoboflowLoadParams) => Promise<RoboflowModel>;
}
interface RoboflowApiProviderProps {
    roboflowAuthParams: RoboflowAuthParams;
    children?: ReactNode;
}

declare class RoboflowApiModel implements RoboflowApi {
    roboflowModule: RoboflowModule;
    constructor(roboflowModule: RoboflowModule);
    load(loadParams: RoboflowLoadParams): Promise<RoboflowModel>;
}

declare const waitForRoboflowModule: () => Promise<void>;
declare const initializeRoboflowApi: (roboflowAuthParams: RoboflowAuthParams) => RoboflowApiModel;

interface RoboflowObjectDetectionCanvasProps {
    width: number;
    height: number;
    objectDetections: RoboflowObjectDetection[];
    mirrored?: boolean;
}

declare const RoboflowObjectDetectionCanvas: ({ width, height, objectDetections, mirrored }: RoboflowObjectDetectionCanvasProps) => react_jsx_runtime.JSX.Element;

declare const RoboflowApiContext: react.Context<RoboflowApi | null>;
declare const useRoboflowApiContext: () => RoboflowApi;
declare const RoboflowApiProvider: ({ roboflowAuthParams, children }: RoboflowApiProviderProps) => react_jsx_runtime.JSX.Element;

interface RoboflowClient {
    load: (loadParams: RoboflowLoadParams) => Promise<RoboflowModel>;
    startInference: (detectCallback: (model: RoboflowModel) => void) => void;
    stopInference: () => void;
}
interface RoboflowClientProviderProps {
    children?: ReactNode;
}

declare const asyncSetInterval: (asyncFunction: any, intervalMs: number) => NodeJS.Timeout;

declare const FACING_MODE_USER = "user";
declare const FACING_MODE_ENVIRONMENT = "environment";
declare const VIDEO_INPUT = "videoinput";
interface VideoInput {
    inputDeviceInfo: InputDeviceInfo;
    mediaTrackCapabilities: MediaTrackCapabilities;
}
interface VideoInputMode {
    deviceId: string;
    label: string;
    facingMode: string;
    aspectRatio?: DoubleRange;
    width?: ULongRange;
    height?: ULongRange;
}

declare const getVideoInputs: () => Promise<VideoInput[]>;
declare const getVideoInputModes: () => Promise<VideoInputMode[]>;

declare class RoboflowClientModel implements RoboflowClient {
    roboflowApi: RoboflowApi;
    private roboflowProject?;
    private roboflowModel?;
    private inferInterval?;
    private inferRunning;
    constructor(roboflowApi: RoboflowApi);
    load({ model, version }: RoboflowLoadParams): Promise<RoboflowModel>;
    startInference(detectCallback: (model: RoboflowModel) => void): void;
    stopInference(): void;
}

declare const RoboflowClientContext: react.Context<RoboflowClient | null>;
declare const useRoboflowClientContext: () => RoboflowClient;
declare const RoboflowClientProvider: ({ children }: RoboflowClientProviderProps) => react_jsx_runtime.JSX.Element;

interface ActiveBreakpoints {
    isXs: boolean;
    isSm: boolean;
    isMd: boolean;
    isLg: boolean;
    isXl: boolean;
    isXxl: boolean;
}

declare const useActiveBreakpoints: () => ActiveBreakpoints;

declare const useForwardRef: <T>(ref: ForwardedRef<T>, initialValue?: any) => react.MutableRefObject<T>;

export { type ActiveBreakpoints, FACING_MODE_ENVIRONMENT, FACING_MODE_USER, type RoboflowApi, RoboflowApiContext, RoboflowApiModel, RoboflowApiProvider, type RoboflowApiProviderProps, type RoboflowAuthParams, type RoboflowBoundingBox, type RoboflowClient, RoboflowClientContext, RoboflowClientModel, RoboflowClientProvider, type RoboflowClientProviderProps, type RoboflowLoadParams, type RoboflowModel, type RoboflowModelConfiguration, type RoboflowModelMetadata, type RoboflowModule, type RoboflowObjectDetection, RoboflowObjectDetectionCanvas, type RoboflowObjectDetectionCanvasProps, type RoboflowProject, RoboflowWebcam, type RoboflowWebcamProps, VIDEO_INPUT, type VideoInput, type VideoInputMode, asyncSetInterval, getVideoInputModes, getVideoInputs, initializeRoboflowApi, useActiveBreakpoints, useForwardRef, useRoboflowApiContext, useRoboflowClientContext, waitForRoboflowModule };