import { AxiosRequestConfig, ResponseType, AxiosError } from 'axios';
import * as Stream from 'node:stream';

declare enum ManagementAndInformation {
    GetConfig = "config",
    ConfigRaw = "config/raw",
    ConfigSchemaJSON = "config/schema.json",
    SaveConfig = "config/save",
    Restart = "restart",
    Stats = "stats",
    Version = "version",
    FFProbe = "ffprobe",
    CameraPTZInfo = "<camera_name>/ptz/info"
}

interface FFProbeQueryParameters {
    paths: string;
}

interface StatsResponse {
    cameras: {
        [key: string]: Camera$1;
    };
    cpu_usages: {
        [key: string]: CPUUsage;
    };
    detection_fps: number;
    detectors: Detectors$1;
    processes: Processes;
    service: Service;
}
interface Camera$1 {
    audio_dBFS: number;
    audio_rms: number;
    camera_fps: number;
    capture_pid: number;
    detection_enabled: number;
    detection_fps: number;
    ffmpeg_pid: number;
    pid: number;
    process_fps: number;
    skipped_fps: number;
}
interface CPUUsage {
    cmdline: string;
    cpu: string;
    cpu_average: string;
    mem: string;
}
interface Detectors$1 {
    coral: Coral$1;
}
interface Coral$1 {
    detection_start: number;
    inference_speed: number;
    pid: number;
}
interface Processes {
    go2rtc: PidResponse;
    logger: PidResponse;
    recording: PidResponse;
}
interface PidResponse {
    pid: number;
}
interface Service {
    last_updated: number;
    latest_version: string;
    storage: {
        [key: string]: Storage;
    };
    temperatures: Temperatures;
    uptime: number;
    version: string;
}
interface Storage {
    free: number;
    mount_type: string;
    total: number;
    used: number;
}
interface Temperatures {
}

interface ConfigResponse {
    audio: Audio;
    birdseye: ConfigResponseBirdseye;
    cameras: {
        [key: string]: Camera;
    };
    database: Database;
    detect: Detect;
    detectors: Detectors;
    environment_vars: EnvironmentVars;
    ffmpeg: Ffmpeg;
    go2rtc: Go2RTC;
    live: Live;
    logger: Logger;
    model: ConfigResponseModel;
    motion: null;
    mqtt: Mqtt;
    objects: ConfigResponseObjects;
    plus: Plus;
    record: Record;
    rtmp: Plus;
    snapshots: Snapshots;
    telemetry: Telemetry;
    timestamp_style: TimestampStyle;
    ui: ConfigResponseUI;
}
interface Audio {
    enabled: boolean;
    enabled_in_config: boolean | null;
    filters: AudioFilters;
    listen: string[];
    max_not_heard: number;
    min_volume: number;
    num_threads: number;
}
interface AudioFilters {
    speech: Speech;
}
interface Speech {
    threshold: number;
}
interface ConfigResponseBirdseye {
    enabled: boolean;
    height: number;
    inactivity_threshold: number;
    layout: Layout;
    mode: string;
    quality: number;
    restream: boolean;
    width: number;
}
interface Layout {
    max_cameras: null;
    scaling_factor: number;
}
interface Camera {
    audio: Audio;
    best_image_timeout: number;
    birdseye: ReolinkBirdseye;
    detect: Detect;
    enabled: boolean;
    ffmpeg: Ffmpeg;
    ffmpeg_cmds: FfmpegCmd[];
    live: Live;
    motion: Motion;
    mqtt: Snapshots;
    name: string;
    objects: ReolinkObjects;
    onvif: Onvif;
    record: Record;
    rtmp: Plus;
    snapshots: Snapshots;
    timestamp_style: TimestampStyle;
    ui: ReolinkUI;
    webui_url: null;
    zones: EnvironmentVars;
}
interface ReolinkBirdseye {
    enabled: boolean;
    mode: string;
    order: number;
}
interface Detect {
    annotation_offset: number;
    enabled: boolean;
    fps: number;
    height: number | null;
    max_disappeared: number | null;
    min_initialized: number | null;
    stationary: Stationary;
    width: number | null;
}
interface Stationary {
    interval: number | null;
    max_frames: MaxFrames;
    threshold: number | null;
}
interface MaxFrames {
    default: null;
    objects: EnvironmentVars;
}
interface EnvironmentVars {
}
interface Ffmpeg {
    global_args: string[];
    hwaccel_args: any[];
    input_args: string;
    inputs?: Input[];
    output_args: OutputArgs;
    retry_interval: number;
}
interface Input {
    global_args: any[];
    hwaccel_args: any[];
    input_args: any[];
    path: string;
    roles: string[];
}
interface OutputArgs {
    detect: string[];
    record: string;
    rtmp: string;
}
interface FfmpegCmd {
    cmd: string;
    roles: string[];
}
interface Live {
    height: number;
    quality: number;
    stream_name: string;
}
interface Motion {
    contour_area: number;
    delta_alpha: number;
    frame_alpha: number;
    frame_height: number;
    improve_contrast: boolean;
    lightning_threshold: number;
    mask: string;
    mqtt_off_delay: number;
    threshold: number;
}
interface Snapshots {
    bounding_box: boolean;
    crop: boolean;
    enabled: boolean;
    height: number | null;
    quality: number;
    required_zones: any[];
    timestamp: boolean;
    clean_copy?: boolean;
    retain?: SnapshotsRetain;
}
interface SnapshotsRetain {
    default: number;
    mode: string;
    objects: EnvironmentVars;
}
interface ReolinkObjects {
    filters: PurpleFilters;
    mask: string;
    track: string[];
}
interface PurpleFilters {
    car: Amazon;
    person: Amazon;
}
interface Amazon {
    mask: null;
    max_area: number;
    max_ratio: number;
    min_area: number;
    min_ratio: number;
    min_score: number;
    threshold: number;
}
interface Onvif {
    autotracking: Autotracking;
    host: string;
    password: null;
    port: number;
    user: null;
}
interface Autotracking {
    calibrate_on_startup: boolean;
    enabled: boolean;
    enabled_in_config: boolean;
    movement_weights: any[];
    required_zones: any[];
    return_preset: string;
    timeout: number;
    track: string[];
    zoom_factor: number;
    zooming: string;
}
interface Record {
    enabled: boolean;
    enabled_in_config: boolean | null;
    events: Events$1;
    expire_interval: number;
    export: Export;
    retain: RecordRetain;
    sync_recordings: boolean;
}
interface Events$1 {
    objects: null;
    post_capture: number;
    pre_capture: number;
    required_zones: any[];
    retain: SnapshotsRetain;
}
interface Export {
    timelapse_args: string;
}
interface RecordRetain {
    days: number;
    mode: string;
}
interface Plus {
    enabled: boolean;
}
interface TimestampStyle {
    color: Color;
    effect: null;
    format: string;
    position: string;
    thickness: number;
}
interface Color {
    blue: number;
    green: number;
    red: number;
}
interface ReolinkUI {
    dashboard: boolean;
    order: number;
}
interface Database {
    path: string;
}
interface Detectors {
    coral: Coral;
}
interface Coral {
    device: string;
    model: CoralModel;
    type: string;
}
interface CoralModel {
    height: number;
    input_pixel_format: string;
    input_tensor: string;
    labelmap: {
        [key: string]: string;
    };
    labelmap_path: null;
    model_type: string;
    path: string;
    width: number;
}
interface Go2RTC {
    streams: Streams;
}
interface Streams {
    back: string[];
}
interface Logger {
    default: string;
    logs: EnvironmentVars;
}
interface ConfigResponseModel {
    height: number;
    input_pixel_format: string;
    input_tensor: string;
    labelmap: EnvironmentVars;
    labelmap_path: null;
    model_type: string;
    path: null;
    width: number;
}
interface Mqtt {
    client_id: string;
    enabled: boolean;
    host: string;
    port: number;
    stats_interval: number;
    tls_ca_certs: null;
    tls_client_cert: null;
    tls_client_key: null;
    tls_insecure: null;
    topic_prefix: string;
    user: null;
}
interface ConfigResponseObjects {
    filters: FluffyFilters;
    mask: string;
    track: string[];
}
interface FluffyFilters {
    amazon: Amazon;
    face: Amazon;
    fedex: Amazon;
    license_plate: Amazon;
    ups: Amazon;
}
interface Telemetry {
    network_interfaces: any[];
    stats: Stats;
    version_check: boolean;
}
interface Stats {
    amd_gpu_stats: boolean;
    intel_gpu_stats: boolean;
    network_bandwidth: boolean;
}
interface ConfigResponseUI {
    date_style: string;
    live_mode: string;
    strftime_fmt: null;
    time_format: string;
    time_style: string;
    timezone: null;
    use_experimental: boolean;
}

interface FFprobeResponse {
    return_code: number;
    stderr: string;
    stdout: object;
}

declare enum Media {
    MJPEGDebugStream = "<camera_name>",
    LatestJPG = "<camera_name>/latest.jpg",
    ThumbnailJPG = "<camera_name>/<label>/thumbnail.jpg",
    ClipMP4 = "<camera_name>/<label>/clip.mp4",
    SnapshotJPG = "<camera_name>/<label>/snapshot.jpg",
    GridJPG = "<camera_name>/grid.jpg"
}

interface MJPEGDebugStream {
    fps?: number;
    h?: number;
    bbox?: 0 | 1;
    timestamp?: 0 | 1;
    zones?: 0 | 1;
    mask?: 0 | 1;
    motion?: 0 | 1;
    regions?: 0 | 1;
}

interface LatestJPG {
    h?: number;
    bbox?: 0 | 1;
    timestamp?: 0 | 1;
    zones?: 0 | 1;
    mask?: 0 | 1;
    motion?: 0 | 1;
    regions?: 0 | 1;
    quality?: number;
}

interface GridJPG {
    color: 'red' | 'green' | 'blue' | 'black' | 'white';
    font_scale: number;
}

declare enum Events {
    Events = "events",
    EventsSummary = "events/summary",
    ById = "events/<event_id>",
    IdRetain = "events/<event_id>/retain",
    SubmitForFrigatePlus = "events/<event_id>/plus",
    SubmitForFrigatePlusFalsePositive = "events/<event_id>/false_positive",
    SubLabel = "events/<event_id>/sub_label",
    ThumbnailJPG = "events/<event_id>/thumbnail.jpg",
    ClipMp4 = "events/<event_id>/clip.mp4",
    SnapshotCleanPNG = "events/<event_id>/snapshot-clean.png",
    SnapshotJPG = "events/<event_id>/snapshot.jpg",
    CreateLabel = "events/<camera_name>/<label>/create",
    EndEvent = "events/<event_id>/end"
}

interface EventsQueryParams {
    before?: number;
    after?: number;
    cameras?: string;
    labels?: string;
    zones?: string;
    limit?: number;
    has_snapshot?: 0 | 1;
    has_clip?: 0 | 1;
    include_thumbnails?: 0 | 1;
    in_progress?: 0 | 1;
    time_range?: string;
    timezone?: string;
    min_score?: number;
    max_score?: number;
    is_submitted?: 0 | 1;
    min_length?: number;
    max_length?: number;
    sort?: 'score_asc' | 'score_desc' | 'date_asc' | 'date_desc';
}

interface EventsResponse {
    box: null;
    camera: string;
    data: Data$3;
    end_time: number;
    false_positive: null;
    has_clip: boolean;
    has_snapshot: boolean;
    id: string;
    label: string;
    plus_id: null;
    retain_indefinitely: boolean;
    start_time: number;
    sub_label: null;
    thumbnail: string;
    top_score: null;
    zones: any[];
}
interface Data$3 {
    attributes: any[];
    box: number[];
    region: number[];
    score: number;
    top_score: number;
    type: string;
}

interface EventsSummaryResponse {
    camera: string;
    count: number;
    day: Date;
    label: string;
    sub_label: null;
    zones: any[];
}

interface EventsByIDResponse {
    area: null;
    box: null;
    camera: string;
    data: Data$2;
    detector_type: string;
    end_time: number;
    false_positive: null;
    has_clip: boolean;
    has_snapshot: boolean;
    id: string;
    label: string;
    model_hash: string;
    model_type: string;
    plus_id: null;
    ratio: number;
    region: null;
    retain_indefinitely: boolean;
    score: null;
    start_time: number;
    sub_label: null;
    thumbnail: string;
    top_score: null;
    zones: any[];
}
interface Data$2 {
    attributes: any[];
    box: number[];
    region: number[];
    score: number;
    top_score: number;
    type: string;
}

interface IdPlus {
    include_annotation?: 0 | 1;
}

interface SubLabelBody {
    subLabel: string;
    subLabelScore: number;
}

interface ThumbnailJPG {
    format: 'android' | 'ios';
}

interface SnapshotCleanPng {
    download: boolean;
}

interface SnapshotJPG {
    h?: number;
    bbox?: 0 | 1;
    timestamp?: 0 | 1;
    crop?: 0 | 1;
    quality?: number;
    download?: boolean;
}

interface CreateLabel {
    sub_label: string;
    duration: number;
    include_recording: boolean;
    draw: Draw;
}
interface Draw {
    boxes: Box[];
}
interface Box {
    box: number[];
    color: number[];
    score: number;
}

interface BasicResponse {
    message: string;
    success: boolean;
}

interface CreateLabelResponse extends BasicResponse {
    event_id: string;
}

declare enum Preview {
    GifFromEvent = "events/<event_id>/preview.gif",
    MetadataForPreviewsInRange = "preview/<camera_name>/start/<start_timestamp>/end/<end_timestamp>",
    MetadataForPreviewsInHour = "preview/<year>-<month>/<day>/<hour>/<camera_name>/<timezone>",
    GifFromRange = "<camera_name>/start/<start_timestamp>/end/<end_timestamp>/preview.gif"
}

interface CameraNameUrlParams {
    camera_name: string;
}

interface MetaDataForPreviewsInRangeUrlParams extends CameraNameUrlParams {
    start_timestamp: number;
    end_timestamp: number;
}

interface CameraAndLabelNameUrlParams {
    camera_name: string;
    label: string;
}

interface EventIdUrlParams {
    event_id: string;
}

interface MetaDataForPreviewsInHourUrlParams extends CameraNameUrlParams {
    year: number;
    month: number;
    day: number;
    hour: number;
    timezone?: string;
}

interface GifFromPreviewUrlParams extends CameraNameUrlParams {
    start_timestamp: number;
    end_timestamp: number;
}

declare enum Recordings {
    VodSpecificHour = "vod/<year>-<month>/<day>/<hour>/<camera_name>",
    VodSpecificHourWithTimezone = "vod/<year>-<month>/<day>/<hour>/<camera_name>/<timezone>",
    VodForEvent = "vod/event/<event_id>",
    M3u8VodForEvent = "vod/event/<event_id>/index.m3u8",
    VodForRange = "vod/<camera_name>/start/<start_timestamp>/end/<end_timestamp>",
    M3u8VodForRange = "vod/<camera_name>/start/<start_timestamp>/end/<end_timestamp>/index.m3u8",
    HourlySummaryRecordings = "<camera_name>/recordings/summary",
    RecordingSegmentsForRange = "<camera_name>/recordings",
    SnapshotPNGSpecificFrame = "<camera_name>/recordings/<frame_time>/snapshot.png"
}

interface StartEndTimestampUrlParams {
    start_timestamp: number;
    end_timestamp: number;
}

interface VodInRangeUrlParams extends CameraNameUrlParams, StartEndTimestampUrlParams {
}

interface ExportTimeRangeMp4Body {
    playback?: 'realtime' | 'timelapse_25x';
    name?: string;
}

interface ExportResponse {
    camera: string;
    date: number;
    id: string;
    in_progress: boolean;
    name: string;
    thumb_path: string;
    video_path: string;
}

interface ExportIdUrlParams {
    export_id: string;
}

interface RenameExportUrlParams extends ExportIdUrlParams {
    export_name_new: string;
}

interface DeleteExportUrlParams extends ExportIdUrlParams {
}

interface ExportTimeRangeMp4ToDiskUrlParams extends CameraNameUrlParams, StartEndTimestampUrlParams {
}

declare enum Exports {
    ListExports = "exports",
    ExportTimeRangeMP4ToDisk = "export/<camera_name>/start/<start_timestamp>/end/<end_timestamp>",
    DeleteExportById = "export/<export_id>",
    RenameExport = "export/<export_id>/<export_name_new>"
}

interface RecordingsPerHourResponse {
    day: Date;
    events: number;
    hours: Hour[];
}
interface Hour {
    duration: number;
    events: number;
    hour: string;
    motion: number;
    objects: number;
}

interface SegmentDetailsForRange {
    after: number;
    before: number;
}

interface RecordingsForRange {
    duration: number;
    end_time: number;
    id: string;
    motion: number;
    objects: number;
    segment_size: number;
    start_time: number;
}

interface SnapshotPNGSpecificFrameUrlParameters extends CameraNameUrlParams {
    frame_time: number;
}

declare enum Timeline {
    Timeline = "timeline"
}

interface TimelineQueryParameters {
    limit?: number;
    camera?: string;
    source_id?: string;
}

interface TimelineResponse {
    camera: string;
    class_type: string;
    data: Data$1;
    source: string;
    source_id: string;
    timestamp: number;
}
interface Data$1 {
    attribute: string;
    box: number[];
    label: string;
    region: number[];
    sub_label: null;
}

declare enum Reviews {
    ListReviews = "review",
    GetReviewById = "review/<review_id>",
    SummaryLast30Days = "review/summary",
    MarkViewedMany = "reviews/viewed",
    MarkReviewedById = "review/<review_id>/viewed",
    DeleteReviewedMany = "reviews/delete",
    MotionActivityForPeriod = "review/activity/motion",
    AudioActivityForPeriod = "review/activity/audio"
}

interface ListReviewsQueryParams {
    before?: number;
    after?: number;
    cameras?: 'all' | string;
    labels?: string;
    reviewed?: number;
    limit?: number;
    severity?: 'alert' | 'detection' | 'significant_motion';
}

interface ReviewResponse {
    camera: string;
    data: Data;
    end_time: number;
    has_been_reviewed: boolean;
    id: string;
    severity: string;
    start_time: number;
    thumb_path: string;
}
interface Data {
    audio: any[];
    detections: string[];
    objects: string[];
    sub_labels: any[];
    zones: any[];
}

interface ReviewIdUrlParams {
    review_id: string;
}

interface ReviewSummaryQueryParameters {
    cameras?: string;
    labels?: string;
    zones?: string;
    timezone?: string;
}

interface SummaryLast30DaysResponse {
    [key: string]: ReviewSummary;
    last24Hours: Omit<ReviewSummary, 'day'>;
}
interface ReviewSummary {
    day?: Date;
    reviewed_alert: number;
    reviewed_detection: number;
    reviewed_motion: number;
    total_alert: number;
    total_detection: number;
    total_motion: number;
}

interface MarkViewedManyBody {
    ids: string[];
}

interface DeleteReviewManyBody {
    ids: string[];
}

interface MotionActivityForPeriodQueryParameters {
    after?: number;
    before?: number;
    cameras?: string;
    scale?: number;
}

interface MotionActivityForPeriod {
    camera: string;
    motion: number;
    start_time: number;
}

interface AudioActivityForPeriod {
    audio: number;
    start_time: number;
}

interface MetadataForPreviewsInRangeResponse {
    camera: string;
    end: number;
    src: string;
    start: number;
    type: string;
}

interface VodSpecificHourUrlParams extends CameraNameUrlParams {
    year: number;
    month: number;
    day: number;
    hour: number;
}

interface VodSpecificHourResponse {
    cache: boolean;
    consistentSequenceMediaInfo: boolean;
    discontinuity: boolean;
    durations: number[];
    segment_duration: number;
    sequences: Sequence[];
}
interface Sequence {
    clips: Clip[];
}
interface Clip {
    keyFrameDurations: number[];
    path: string;
    type: Type;
}
declare enum Type {
    Source = "source"
}

interface VodSpecificHourWithTimezoneUrlParams extends VodSpecificHourUrlParams {
    timezone: string;
}

interface AudioActivityForPeriodQueryParameters {
    after?: number;
    before?: number;
    cameras?: string;
    scale?: number;
}

interface RestartResponse {
    message: string;
    success: boolean;
}

interface SaveConfigQueryParameters {
    save_option: 'saveonly' | 'restart';
}

interface ManagementAndInformationGetMethods {
    [ManagementAndInformation.GetConfig]: {
        urlParams: undefined;
        queryParams: undefined;
        response: ConfigResponse;
    };
    [ManagementAndInformation.ConfigRaw]: {
        urlParams: undefined;
        queryParams: undefined;
        response: string;
    };
    [ManagementAndInformation.ConfigSchemaJSON]: {
        urlParams: undefined;
        queryParams: undefined;
        response: JSON;
    };
    [ManagementAndInformation.SaveConfig]: {
        urlParams: undefined;
        queryParams: SaveConfigQueryParameters;
        response: BasicResponse;
    };
    [ManagementAndInformation.Stats]: {
        urlParams: undefined;
        queryParams: undefined;
        response: StatsResponse;
    };
    [ManagementAndInformation.Version]: {
        urlParams: undefined;
        queryParams: undefined;
        response: string;
    };
    [ManagementAndInformation.FFProbe]: {
        urlParams: undefined;
        queryParams: FFProbeQueryParameters;
        response: {
            [key: string]: FFprobeResponse;
        };
    };
    [ManagementAndInformation.CameraPTZInfo]: {
        urlParams: CameraNameUrlParams;
        queryParams: undefined;
        response: any;
    };
}
interface MediaGetMethods {
    [Media.MJPEGDebugStream]: {
        urlParams: CameraNameUrlParams;
        queryParams: MJPEGDebugStream;
        response: Stream;
    };
    [Media.LatestJPG]: {
        urlParams: CameraNameUrlParams;
        queryParams: LatestJPG;
        response: Uint8Array;
    };
    [Media.ThumbnailJPG]: {
        urlParams: CameraAndLabelNameUrlParams;
        queryParams: undefined;
        response: Uint8Array;
    };
    [Media.ClipMP4]: {
        urlParams: CameraAndLabelNameUrlParams;
        queryParams: undefined;
        response: Uint8Array;
    };
    [Media.SnapshotJPG]: {
        urlParams: CameraAndLabelNameUrlParams;
        queryParams: undefined;
        response: Uint8Array;
    };
    [Media.GridJPG]: {
        urlParams: CameraNameUrlParams;
        queryParams: GridJPG;
        response: Uint8Array;
    };
}
interface EventsGetMethods {
    [Events.Events]: {
        urlParams: undefined;
        queryParams: EventsQueryParams;
        response: EventsResponse[];
    };
    [Events.EventsSummary]: {
        urlParams: undefined;
        queryParams: undefined;
        response: EventsSummaryResponse;
    };
    [Events.ById]: {
        urlParams: EventIdUrlParams;
        queryParams: undefined;
        response: EventsByIDResponse;
    };
    [Events.ThumbnailJPG]: {
        urlParams: EventIdUrlParams;
        queryParams: ThumbnailJPG;
        response: Uint8Array;
    };
    [Events.ClipMp4]: {
        urlParams: EventIdUrlParams;
        queryParams: undefined;
        response: Uint8Array;
    };
    [Events.SnapshotCleanPNG]: {
        urlParams: EventIdUrlParams;
        queryParams: SnapshotCleanPng;
        response: Uint8Array;
    };
    [Events.SnapshotJPG]: {
        urlParams: EventIdUrlParams;
        queryParams: SnapshotJPG;
        response: Uint8Array;
    };
}
interface PreviewsGetMethods {
    [Preview.GifFromEvent]: {
        urlParams: EventIdUrlParams;
        queryParams: undefined;
        response: Uint8Array;
    };
    [Preview.MetadataForPreviewsInRange]: {
        urlParams: MetaDataForPreviewsInRangeUrlParams;
        queryParams: undefined;
        response: MetadataForPreviewsInRangeResponse[];
    };
    [Preview.MetadataForPreviewsInHour]: {
        urlParams: MetaDataForPreviewsInHourUrlParams;
        queryParams: undefined;
        response: MetadataForPreviewsInRangeResponse[];
    };
    [Preview.GifFromRange]: {
        urlParams: GifFromPreviewUrlParams;
        queryParams: undefined;
        response: Uint8Array;
    };
}
interface ExportsGetMethods {
    [Exports.ListExports]: {
        urlParams: undefined;
        queryParams: undefined;
        response: ExportResponse[];
    };
}
interface RecordingsGetMethods {
    [Recordings.VodSpecificHour]: {
        urlParams: VodSpecificHourUrlParams;
        queryParams: undefined;
        response: VodSpecificHourResponse[];
    };
    [Recordings.VodSpecificHourWithTimezone]: {
        urlParams: VodSpecificHourWithTimezoneUrlParams;
        queryParams: undefined;
        response: VodSpecificHourResponse[];
    };
    [Recordings.VodForEvent]: {
        urlParams: EventIdUrlParams;
        queryParams: undefined;
        response: VodSpecificHourResponse;
    };
    [Recordings.M3u8VodForEvent]: {
        urlParams: EventIdUrlParams;
        queryParams: undefined;
        response: VodSpecificHourResponse;
    };
    [Recordings.VodForRange]: {
        urlParams: VodInRangeUrlParams;
        queryParams: undefined;
        response: VodSpecificHourResponse[];
    };
    [Recordings.M3u8VodForRange]: {
        urlParams: VodInRangeUrlParams;
        queryParams: undefined;
        response: VodSpecificHourResponse[];
    };
    [Recordings.HourlySummaryRecordings]: {
        urlParams: CameraNameUrlParams;
        queryParams: undefined;
        response: RecordingsPerHourResponse[];
    };
    [Recordings.RecordingSegmentsForRange]: {
        urlParams: CameraNameUrlParams;
        queryParams: SegmentDetailsForRange;
        response: RecordingsForRange[];
    };
    [Recordings.SnapshotPNGSpecificFrame]: {
        urlParams: SnapshotPNGSpecificFrameUrlParameters;
        queryParams: undefined;
        response: Uint8Array;
    };
}
interface TimelineGetMethods {
    [Timeline.Timeline]: {
        urlParams: undefined;
        queryParams: TimelineQueryParameters;
        response: TimelineResponse[];
    };
}
interface ReviewsGetMethods {
    [Reviews.ListReviews]: {
        urlParams: undefined;
        queryParams: ListReviewsQueryParams;
        response: ReviewResponse[];
    };
    [Reviews.GetReviewById]: {
        urlParams: ReviewIdUrlParams;
        queryParams: undefined;
        response: ReviewResponse;
    };
    [Reviews.SummaryLast30Days]: {
        urlParams: undefined;
        queryParams: ReviewSummaryQueryParameters;
        response: SummaryLast30DaysResponse;
    };
    [Reviews.MotionActivityForPeriod]: {
        urlParams: undefined;
        queryParams: MotionActivityForPeriodQueryParameters;
        response: MotionActivityForPeriod[];
    };
    [Reviews.AudioActivityForPeriod]: {
        urlParams: undefined;
        queryParams: AudioActivityForPeriodQueryParameters;
        response: AudioActivityForPeriod[];
    };
}
interface FrigateApiGetEndpointsMapping extends ManagementAndInformationGetMethods, MediaGetMethods, EventsGetMethods, PreviewsGetMethods, ExportsGetMethods, RecordingsGetMethods, TimelineGetMethods, ReviewsGetMethods {
}
interface ManagementAndInformationPostMethods {
    [ManagementAndInformation.Restart]: {
        urlParams: undefined;
        queryParams: undefined;
        body: undefined;
        response: RestartResponse;
    };
}
interface EventsPostMethods {
    [Events.IdRetain]: {
        urlParams: EventIdUrlParams;
        queryParams: undefined;
        body: undefined;
        response: BasicResponse;
    };
    [Events.SubmitForFrigatePlus]: {
        urlParams: EventIdUrlParams;
        queryParams: IdPlus;
        body: undefined;
        response: BasicResponse;
    };
    [Events.SubmitForFrigatePlusFalsePositive]: {
        urlParams: EventIdUrlParams;
        queryParams: undefined;
        body: undefined;
        response: BasicResponse;
    };
    [Events.SubLabel]: {
        urlParams: EventIdUrlParams;
        queryParams: undefined;
        body: SubLabelBody;
        response: BasicResponse;
    };
    [Events.CreateLabel]: {
        urlParams: CameraAndLabelNameUrlParams;
        queryParams: undefined;
        body: CreateLabel;
        response: CreateLabelResponse;
    };
}
interface RecordingsPostMethods {
    [Exports.ExportTimeRangeMP4ToDisk]: {
        urlParams: ExportTimeRangeMp4ToDiskUrlParams;
        queryParams: undefined;
        body?: ExportTimeRangeMp4Body;
        response: BasicResponse;
    };
}
interface ReviewsPostMethods {
    [Reviews.MarkViewedMany]: {
        urlParams: undefined;
        queryParams: undefined;
        body?: MarkViewedManyBody;
        response: BasicResponse;
    };
    [Reviews.DeleteReviewedMany]: {
        urlParams: undefined;
        queryParams: undefined;
        body: DeleteReviewManyBody;
        response: BasicResponse;
    };
}
interface FrigateApiPostEndpointsMapping extends ManagementAndInformationPostMethods, EventsPostMethods, RecordingsPostMethods, ReviewsPostMethods {
}
interface FrigateApiPutEndpointsMapping {
    [Events.EndEvent]: {
        urlParams: EventIdUrlParams;
        queryParams: undefined;
        body: undefined;
        response: BasicResponse;
    };
}
interface EventsDeleteMethods {
    [Events.ById]: {
        urlParams: EventIdUrlParams;
        queryParams: undefined;
        response: BasicResponse;
    };
    [Events.IdRetain]: {
        urlParams: EventIdUrlParams;
        queryParams: undefined;
        response: BasicResponse;
    };
    [Exports.DeleteExportById]: {
        urlParams: DeleteExportUrlParams;
        queryParams: undefined;
        response: BasicResponse;
    };
}
interface ReviewsDeleteMethods {
    [Reviews.MarkReviewedById]: {
        urlParams: ReviewIdUrlParams;
        queryParams: undefined;
        response: BasicResponse;
    };
}
interface FrigateApiDeleteEndpointsMapping extends EventsDeleteMethods, ReviewsDeleteMethods {
}
interface FrigateApiPatchEndpointsMapping {
    [Exports.RenameExport]: {
        urlParams: RenameExportUrlParams;
        queryParams: undefined;
        body?: undefined;
        response: BasicResponse;
    };
}

interface FrigateHttpApiConfiguration {
    defaultTimeout?: number;
    frigateHTTPAPIURL: string;
}

declare class FrigateHTTPAPI {
    static FRIGATE_API_PREFIX: string;
    private static apiConfiguration;
    static get defaultRequestConfig(): AxiosRequestConfig;
    static set configuration(config: FrigateHttpApiConfiguration);
    static get defaultTimeout(): number;
    static getFrigateAPIURL(endpoint: string): string;
    static throwIfConfigNotSet(): void;
    static getURL<E extends keyof (FrigateApiGetEndpointsMapping & FrigateApiDeleteEndpointsMapping & FrigateApiPatchEndpointsMapping & FrigateApiPostEndpointsMapping & FrigateApiPutEndpointsMapping)>(endpoint: E, urlParams?: {
        [key: string]: any;
    }, queryParams?: {
        [key: string]: any;
    }): string;
    static get<E extends keyof FrigateApiGetEndpointsMapping>(endpoint: E, urlParams?: FrigateApiGetEndpointsMapping[typeof endpoint]['urlParams'], queryParams?: FrigateApiGetEndpointsMapping[typeof endpoint]['queryParams'], responseType?: ResponseType): Promise<FrigateApiGetEndpointsMapping[typeof endpoint]['response']>;
    static delete<E extends keyof FrigateApiDeleteEndpointsMapping>(endpoint: E, urlParams?: FrigateApiDeleteEndpointsMapping[typeof endpoint]['urlParams']): Promise<FrigateApiDeleteEndpointsMapping[typeof endpoint]['response']>;
    static patch<E extends keyof FrigateApiPatchEndpointsMapping>(endpoint: E, urlParams?: FrigateApiPatchEndpointsMapping[typeof endpoint]['urlParams']): Promise<FrigateApiPatchEndpointsMapping[typeof endpoint]['response']>;
    static post<E extends keyof FrigateApiPostEndpointsMapping>(endpoint: E, urlParams?: FrigateApiPostEndpointsMapping[typeof endpoint]['urlParams'], queryParams?: FrigateApiPostEndpointsMapping[typeof endpoint]['queryParams'], body?: FrigateApiPostEndpointsMapping[typeof endpoint]['body']): Promise<FrigateApiPostEndpointsMapping[typeof endpoint]['response']>;
    static put<E extends keyof FrigateApiPutEndpointsMapping>(endpoint: E, urlParams?: FrigateApiPutEndpointsMapping[typeof endpoint]['urlParams'], queryParams?: FrigateApiPutEndpointsMapping[typeof endpoint]['queryParams'], body?: FrigateApiPutEndpointsMapping[typeof endpoint]['body']): Promise<FrigateApiPutEndpointsMapping[typeof endpoint]['response']>;
    static throwError(endpoint: string, url: string, e: AxiosError): void;
    private static queryStringify;
}

declare function interpolateURLParams(endpoint: string, params?: {
    [key: string]: any;
}): string;

export { type AudioActivityForPeriod, type AudioActivityForPeriodQueryParameters, type BasicResponse, type CameraAndLabelNameUrlParams, type CameraNameUrlParams, type ConfigResponse, type CreateLabel, type CreateLabelResponse, type DeleteExportUrlParams, type DeleteReviewManyBody, type EventIdUrlParams, Events, type EventsByIDResponse, type EventsQueryParams, type EventsResponse, type EventsSummaryResponse, type ExportIdUrlParams, type ExportResponse, type ExportTimeRangeMp4Body, type ExportTimeRangeMp4ToDiskUrlParams, Exports, type FFProbeQueryParameters, type FFprobeResponse, type FrigateApiDeleteEndpointsMapping, type FrigateApiGetEndpointsMapping, type FrigateApiPatchEndpointsMapping, type FrigateApiPostEndpointsMapping, type FrigateApiPutEndpointsMapping, FrigateHTTPAPI, type FrigateHttpApiConfiguration, type GifFromPreviewUrlParams, type GridJPG, type IdPlus, type LatestJPG, type ListReviewsQueryParams, type MJPEGDebugStream, ManagementAndInformation, type MarkViewedManyBody, Media, type MetaDataForPreviewsInHourUrlParams, type MetaDataForPreviewsInRangeUrlParams, type MetadataForPreviewsInRangeResponse, type MotionActivityForPeriod, type MotionActivityForPeriodQueryParameters, Preview, Recordings, type RecordingsForRange, type RecordingsPerHourResponse, type RenameExportUrlParams, type RestartResponse, type ReviewIdUrlParams, type ReviewResponse, type ReviewSummaryQueryParameters, Reviews, type SaveConfigQueryParameters, type SegmentDetailsForRange, type SnapshotCleanPng, type SnapshotJPG, type SnapshotPNGSpecificFrameUrlParameters, type StartEndTimestampUrlParams, type StatsResponse, type SubLabelBody, type SummaryLast30DaysResponse, type ThumbnailJPG, Timeline, type TimelineQueryParameters, type TimelineResponse, type VodInRangeUrlParams, type VodSpecificHourResponse, type VodSpecificHourUrlParams, type VodSpecificHourWithTimezoneUrlParams, interpolateURLParams };