import type { AssistantToolReference } from '@camera.ui/sdk';
import { AudioProperty } from '@camera.ui/sdk';
import { AudioSensorProperties } from '@camera.ui/sdk';
import type { BaseCamera } from '@camera.ui/sdk';
import { BasePlugin } from '@camera.ui/sdk';
import { BatteryInfoProperties } from '@camera.ui/sdk';
import { BatteryProperty } from '@camera.ui/sdk';
import { Camera } from '@camera.ui/sdk';
import type { CameraInputSettings } from '@camera.ui/sdk/internal';
import { CameraSource } from '@camera.ui/sdk';
import { CarbonDioxideInfoProperties } from '@camera.ui/sdk';
import { CarbonDioxideProperty } from '@camera.ui/sdk';
import { CarbonMonoxideProperty } from '@camera.ui/sdk';
import { CarbonMonoxideSensorProperties } from '@camera.ui/sdk';
import { ChargingState } from '@camera.ui/sdk';
import { ClassifierProperty } from '@camera.ui/sdk';
import { ClassifierSensorProperties } from '@camera.ui/sdk';
import { ColdProperty } from '@camera.ui/sdk';
import { ColdSensorProperties } from '@camera.ui/sdk';
import { ComputedRef } from 'vue';
import { ConnectionTarget } from '@camera.ui/transport';
import { ContactProperty } from '@camera.ui/sdk';
import { ContactSensorProperties } from '@camera.ui/sdk';
import { CoreManager } from '@camera.ui/sdk';
import { Detection } from '@camera.ui/sdk';
import { DoorbellProperty } from '@camera.ui/sdk';
import { DoorbellTriggerProperties } from '@camera.ui/sdk';
import { FaceDetection } from '@camera.ui/sdk';
import { FaceProperty } from '@camera.ui/sdk';
import { FaceSensorProperties } from '@camera.ui/sdk';
import { FormSubmitResponse } from '@camera.ui/sdk';
import { GarageControlProperties } from '@camera.ui/sdk';
import { GarageProperty } from '@camera.ui/sdk';
import { GarageState } from '@camera.ui/sdk';
import { GasProperty } from '@camera.ui/sdk';
import { GasSensorProperties } from '@camera.ui/sdk';
import { HeatProperty } from '@camera.ui/sdk';
import { HeatSensorProperties } from '@camera.ui/sdk';
import { HTMLAttributes } from 'vue';
import { HumidityInfoProperties } from '@camera.ui/sdk';
import { HumidityProperty } from '@camera.ui/sdk';
import { IlluminanceInfoProperties } from '@camera.ui/sdk';
import { IlluminanceProperty } from '@camera.ui/sdk';
import { InjectionKey } from 'vue';
import type { JSONSchema } from '@tanstack/ai';
import { LeakProperty } from '@camera.ui/sdk';
import { LeakSensorProperties } from '@camera.ui/sdk';
import { LicensePlateDetection } from '@camera.ui/sdk';
import { LicensePlateProperty } from '@camera.ui/sdk';
import { LicensePlateSensorProperties } from '@camera.ui/sdk';
import { LightControlProperties } from '@camera.ui/sdk';
import { LightProperty } from '@camera.ui/sdk';
import { LockControlProperties } from '@camera.ui/sdk';
import { LockProperty } from '@camera.ui/sdk';
import { LockState } from '@camera.ui/sdk';
import { MaybeRefOrGetter } from 'vue';
import type { ModelSpec } from '@camera.ui/sdk';
import { MotionProperty } from '@camera.ui/sdk';
import { MotionSensorProperties } from '@camera.ui/sdk';
import { Status as NatsStatus } from '@camera.ui/rpc';
import { NatsTransport } from '@camera.ui/transport/transports/nats';
import { OAuthMetadata } from '@camera.ui/sdk';
import { OAuthState } from '@camera.ui/sdk';
import { ObjectProperty } from '@camera.ui/sdk';
import { ObjectSensorProperties } from '@camera.ui/sdk';
import { OccupancyProperty } from '@camera.ui/sdk';
import { OccupancySensorProperties } from '@camera.ui/sdk';
import { PluginContract } from '@camera.ui/sdk';
import type { PluginInfo } from '@camera.ui/sdk';
import type { PluginInterface } from '@camera.ui/sdk';
import { PluginInterfaces } from '@camera.ui/sdk';
import { PowerProperty } from '@camera.ui/sdk';
import { PowerSensorProperties } from '@camera.ui/sdk';
import { ProbeConfig } from '@camera.ui/sdk';
import { ProbeStream } from '@camera.ui/sdk';
import { ProblemProperty } from '@camera.ui/sdk';
import { ProblemSensorProperties } from '@camera.ui/sdk';
import { Promisify } from '@camera.ui/rpc';
import { PropertyChangedEvent } from '@camera.ui/sdk/internal';
import { PTZControlProperties } from '@camera.ui/sdk';
import { PTZDirection } from '@camera.ui/sdk';
import { PTZPosition } from '@camera.ui/sdk';
import { PTZProperty } from '@camera.ui/sdk';
import { Ref } from 'vue';
import { RPCClient } from '@camera.ui/rpc';
import { SchemaConfig } from '@camera.ui/sdk';
import { SecuritySystemProperties } from '@camera.ui/sdk';
import { SecuritySystemProperty } from '@camera.ui/sdk';
import { SecuritySystemState } from '@camera.ui/sdk';
import type { SensorSourceState } from '@camera.ui/sdk';
import { SensorType } from '@camera.ui/sdk';
import { ShallowRef } from 'vue';
import { SirenControlProperties } from '@camera.ui/sdk';
import { SirenProperty } from '@camera.ui/sdk';
import { SmokeProperty } from '@camera.ui/sdk';
import { SmokeSensorProperties } from '@camera.ui/sdk';
import type { SnapshotInterface } from '@camera.ui/sdk';
import type { StreamingInterface } from '@camera.ui/sdk';
import { StreamingRole } from '@camera.ui/sdk';
import { SwitchControlProperties } from '@camera.ui/sdk';
import { SwitchProperty } from '@camera.ui/sdk';
import { TamperProperty } from '@camera.ui/sdk';
import { TamperSensorProperties } from '@camera.ui/sdk';
import { TemperatureInfoProperties } from '@camera.ui/sdk';
import { TemperatureProperty } from '@camera.ui/sdk';
import { VibrationProperty } from '@camera.ui/sdk';
import { VibrationSensorProperties } from '@camera.ui/sdk';
import { WatchSource } from 'vue';
import { WsTransport } from '@camera.ui/transport/transports/ws';

export declare function acquireSensorManager(rpcOrContext: RPCClient | ReactiveCameraDeviceContext): CachedSensorManager;

export declare interface ActivityMode extends ActivityModeState, ActivityModeActions {
}

declare interface ActivityModeActions {
    setMode: (mode: CameraActivityMode) => void;
    reportActivity: (hasActivity: boolean) => void;
    resumeFromStandby: () => void;
    resetIdleTimer: () => void;
    dispose: () => void;
}

export declare interface ActivityModeConfig {
    standbyTimeout?: number;
    activityTimeout?: number;
}

declare interface ActivityModeState {
    readonly mode: Ref<CameraActivityMode>;
    readonly inStandby: Ref<boolean>;
    readonly hasActivity: Ref<boolean>;
}

declare interface AssistantAccess {
    allowed: boolean;
    model: string | null;
    vision: boolean | null;
    language: string | null;
}

declare interface AssistantAskRequest {
    pluginId: string;
    prompt: string;
    system?: string;
    images?: { data: Uint8Array; mimeType: string }[];
    outputSchema?: JSONSchema;
    timeoutMs?: number;
}

declare type AssistantAskResult =
| { ok: true; text: string; json?: unknown; usage: { promptTokens: number; completionTokens: number } }
| { ok: false; reason: 'not_allowed' | 'unconfigured' | 'timeout' | 'error'; message: string };

declare interface AssistantPost {
    userId: string;
    threadId: string;
    title?: string;
    text: string;
    label?: string;
    image?: { data: string; mimeType: string };
    references?: AssistantToolReference[];
}

/* Excluded from this release type: AudioProperty */

/* Excluded from this release type: AudioSensorProperties */

export declare interface BaseLogger {
    log: (...args: unknown[]) => void;
    error: (...args: unknown[]) => void;
    warn: (...args: unknown[]) => void;
    success: (...args: unknown[]) => void;
    debug: (...args: unknown[]) => void;
    trace: (...args: unknown[]) => void;
    attention: (...args: unknown[]) => void;
}

/* Excluded from this release type: BatteryInfoProperties */

/* Excluded from this release type: BatteryProperty */

declare interface CachedSensorManager {
    manager: ReactiveSensorManager;
    initPromise?: Promise<void>;
}

export declare const CAMERA_UI_INJECTION_KEY: InjectionKey<CameraUiContext>;

export declare type CameraActivityMode = 'always-on' | 'standby' | 'activity';

declare type CameraDeviceImplementation = PartialReturnType<StreamingInterface> & PartialReturnType<SnapshotInterface>;

export declare interface CameraDeviceInterface extends CameraDeviceImplementation {
    refreshStates(): Promise<RefreshedStates>;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    snapshot(sourceId: string, forceNew?: boolean, preferNative?: boolean): Promise<ArrayBuffer | undefined>;
    snapshotWithMeta(sourceId: string, forceNew?: boolean): Promise<SnapshotWithMeta | undefined>;
    probeStream(sourceId: string, probeConfig?: ProbeConfig, refresh?: boolean): Promise<ProbeStream | undefined>;
    getStreamStatus(sourceId: string): Promise<string>;
}

declare type CameraIdentifier = MaybeRefOrGetter<string | ReactiveCameraDevice | undefined>;

export declare interface CameraNamespaces {
    cameraSubject: string;
    cameraControllerRpc: string;
}

export declare interface CameraStream {
    readonly status: Ref<StreamStatus>;
    readonly isPlaying: Ref<boolean>;
    readonly activeMode: Ref<'webrtc' | 'webrtc/tcp' | 'mse'>;
    readonly activeResolution: Ref<StreamingRole>;
    readonly degradedFrom: Ref<StreamingRole | null>;
    readonly unsupported: Ref<boolean>;
    readonly hasAudio: Ref<boolean>;
    readonly hasBackchannel: Ref<boolean>;
    readonly error: Ref<Error | undefined>;
    readonly isReconnecting: Ref<boolean>;
    readonly activityMode: Ref<CameraActivityMode>;
    readonly inStandby: Ref<boolean>;
    readonly hasActivity: Ref<boolean>;
    readonly isBusy: Ref<boolean>;
    readonly hasSound: Ref<boolean>;
    readonly hasIntercom: Ref<boolean>;
    readonly stream: ShallowRef<ReactiveStream | undefined>;
    readonly videoElement: ShallowRef<HTMLVideoElement | undefined>;
    readonly containerElement: ShallowRef<HTMLElement | undefined>;
    readonly fullscreenElement: ShallowRef<HTMLElement | undefined>;
    readonly renderElement: ComputedRef<HTMLVideoElement | HTMLCanvasElement | undefined>;
    readonly muted: ComputedRef<boolean>;
    readonly paused: ComputedRef<boolean>;
    readonly nativeWidth: Ref<number>;
    readonly nativeHeight: Ref<number>;
    readonly isPip: Ref<boolean>;
    readonly supportsPip: ComputedRef<boolean>;
    readonly isFullscreen: Ref<boolean>;
    readonly isCameraDisabled: ComputedRef<boolean>;
    start: () => Promise<void>;
    stop: () => void;
    restart: () => Promise<void>;
    resumeFromStandby: () => void;
    setMode: (mode: VideoStreamingMode) => Promise<void>;
    setResolution: (resolution: StreamingRole) => Promise<void>;
    setMicrophone: (track: MediaStreamTrack | null) => Promise<void>;
    setActivityMode: (mode: CameraActivityMode) => void;
    reportActivity: (hasActivity: boolean) => void;
    setMuted: (muted: boolean) => void;
    play: () => Promise<void>;
    pause: () => void;
    togglePip: () => void;
    toggleFullscreen: () => Promise<void>;
    captureScreenshot: () => string | null;
}

export declare interface CameraUiContext {
    rpc: ShallowRef<RPCClient | undefined>;
    target: Readonly<Ref<ConnectionTarget | null>>;
    isConnected: Readonly<Ref<boolean>>;
    endpoint: Readonly<Ref<string | undefined>>;
    token: Readonly<Ref<string | undefined>>;
    extraProxyQuery: Readonly<Ref<Record<string, string> | undefined>>;
    error: Readonly<Ref<Error | undefined>>;
    wsTransport?: WsTransport;
    on: (event: CameraUiEventType, cb: CameraUiEventCallback) => void;
    off: (event: CameraUiEventType, cb: CameraUiEventCallback) => void;
}

export declare type CameraUiEventCallback = () => void;

export declare type CameraUiEventType = 'reconnected' | 'disconnected';

export declare type CameraUiPlugin = ReturnType<typeof createCameraUiPlugin>;

export declare interface CameraUiPluginInput {
    natsTransport: NatsTransport;
    target: Ref<ConnectionTarget | null>;
    wsTransport?: WsTransport;
}

/* Excluded from this release type: CarbonDioxideInfoProperties */

/* Excluded from this release type: CarbonDioxideProperty */

/* Excluded from this release type: CarbonMonoxideProperty */

/* Excluded from this release type: CarbonMonoxideSensorProperties */

/* Excluded from this release type: ClassifierProperty */

/* Excluded from this release type: ClassifierSensorProperties */

export declare function clearCameraCache(): void;

export declare function clearOAuthCache(): void;

export declare function clearPluginCache(): void;

export declare function clearSensorCache(): void;

export declare function clearSnapshotCache(): void;

export declare function clearStorageCache(): void;

export declare interface CodecCompatibility {
    compatible: boolean;
    audioCompatible: boolean;
    videoCompatible: boolean;
    incompatibleCodecs: string[];
}

/* Excluded from this release type: ColdProperty */

/* Excluded from this release type: ColdSensorProperties */

/* Excluded from this release type: ContactProperty */

/* Excluded from this release type: ContactSensorProperties */

export declare interface CoreManagerInterface {
    ingestTrainingCandidate(payload: TrainingCandidateIngest): Promise<TrainingIngestResult>;
    getTrainingCollectionEnabled(): Promise<boolean>;
    getFFmpegPath(): Promise<string>;
    getServerAddresses(): Promise<string[]>;
    getCloudServerId(): Promise<string>;
    getPlugin(pluginName: string): Promise<HostPluginInfo | undefined>;
    getPluginsByInterface(interfaceName: PluginInterface): Promise<HostPluginInfo[]>;
    getFloorPlan(): Promise<FloorPlan>;
    assistantAsk(request: AssistantAskRequest): Promise<AssistantAskResult>;
    assistantAccess(pluginId: string): Promise<AssistantAccess>;
    assistantPost(post: AssistantPost): Promise<boolean>;
}

export declare interface CoreManagerNamespaces {
    coreManagerSubject: string;
    coreManagerRpc: string;
}

export declare function createActivityMode(options: CreateActivityModeOptions): ActivityMode;

declare interface CreateActivityModeOptions {
    initialMode?: CameraActivityMode;
    config?: ActivityModeConfig;
    onStreamStart: () => void;
    onStreamStop: () => void;
    isStreamPlaying: () => boolean;
}

export declare function createCameraUiPlugin(input: CameraUiContext | CameraUiPluginInput): {
    install(app: {
        provide: (key: symbol, value: unknown) => void;
    }): void;
};

export declare function createReactiveCameraDevice(rpcOrContext: RPCClient | ReactiveCameraDeviceContext, initialCamera: Camera): Promise<ReactiveCameraDevice>;

export declare function createSensorManager(rpcOrContext: RPCClient | ReactiveCameraDeviceContext): ReactiveSensorManager;

declare interface DBCamera extends BaseCamera {
    sources: CameraInputSettings[];
    workerAgentId?: string;
    roomId: string | null;
}

declare interface DBFloorPlan {
    version: number;
    updatedAt: number;
    north: number | null;
    rooms: DBFloorPlanRoom[];
    connections: DBFloorPlanConnection[];
    cameras: DBFloorPlanCamera[];
    sensors: DBFloorPlanSensor[];
}

declare interface DBFloorPlanCamera {
    cameraId: string;
    roomId: string;
    note: string;
    x: number;
    y: number;
    rotation: number;
    fov: number;
    range: number;
}

declare interface DBFloorPlanConnection {
    id: string;
    fromRoomId: string;
    toRoomId: string;
    fromShapeId: string | null;
    toShapeId: string | null;
    offset: number | null;
    width: number;
    note: string;
    type: DBFloorPlanConnectionType;
}

declare type DBFloorPlanConnectionType = 'door' | 'opening' | 'stairs';

declare interface DBFloorPlanRoom {
    id: string;
    roomId: string;
    x: number;
    y: number;
    width: number;
    height: number;
}

declare interface DBFloorPlanSensor {
    sensorId: string;
    sensorType: string;
    roomId: string;
    connectionId: string | null;
    note: string;
    x: number;
    y: number;
}

declare interface DBLevel {
    id: string;
    name: string;
    order: number;
}

declare interface DBRoom {
    id: string;
    name: string;
    levelId: string | null;
    outdoor: boolean;
    publicSpace: boolean;
    note: string;
}

declare interface DBRoomCatalog {
    version: number;
    updatedAt: number;
    levels: DBLevel[];
    rooms: DBRoom[];
}

declare interface DetectionEventNamespaces {
    detectionEventSubject: string;
}

export declare interface DeviceManagerInterface {
    getCamera(cameraNameOrId: string, pluginId: string): Promise<Camera | undefined>;
}

export declare interface DeviceManagerNamespaces {
    deviceManagerSubject: string;
    deviceManagerRpc: string;
}

declare interface DiscoveryManagerNamespaces {
    discoveryManagerSubject: string;
    discoveryManagerRpc: string;
}

/* Excluded from this release type: DoorbellProperty */

/* Excluded from this release type: DoorbellTriggerProperties */

declare interface DownloadManagerNamespaces {
    downloadManagerRpc: string;
}

/* Excluded from this release type: FaceProperty */

/* Excluded from this release type: FaceSensorProperties */

declare interface FloorPlan {
    rooms: DBRoomCatalog;
    plan: DBFloorPlan;
}

declare interface FrameWorkerDetectionNamespaces {
    detectionRpc: string;
}

export declare interface FrameWorkerNamespaces {
    frameWorkerChildRpc: string;
    frameWorkerChild: string;
}

declare type FullscreenMode = 'fit' | 'scroll';

/* Excluded from this release type: GarageControlProperties */

/* Excluded from this release type: GarageProperty */

/* Excluded from this release type: GasProperty */

/* Excluded from this release type: GasSensorProperties */

export declare function getSnapshotUrl(cameraId: string): string | undefined;

/* Excluded from this release type: HeatProperty */

/* Excluded from this release type: HeatSensorProperties */

declare type HiddenCallback = () => void;

declare interface HostPluginInfo extends PluginInfo {
    running: boolean;
}

/* Excluded from this release type: HumidityInfoProperties */

/* Excluded from this release type: HumidityProperty */

/* Excluded from this release type: IlluminanceInfoProperties */

/* Excluded from this release type: IlluminanceProperty */

export declare const isReactiveAudioSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveAudioSensor;

export declare const isReactiveBatteryInfo: (sensor: ReactiveSensor<any>) => sensor is ReactiveBatteryInfo;

export declare const isReactiveCarbonDioxideInfo: (sensor: ReactiveSensor<any>) => sensor is ReactiveCarbonDioxideInfo;

export declare const isReactiveCarbonMonoxideSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveCarbonMonoxideSensor;

export declare const isReactiveClassifierSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveClassifierSensor;

export declare const isReactiveColdSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveColdSensor;

export declare const isReactiveContactSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveContactSensor;

export declare const isReactiveDoorbellTrigger: (sensor: ReactiveSensor<any>) => sensor is ReactiveDoorbellTrigger;

export declare const isReactiveFaceSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveFaceSensor;

export declare const isReactiveGarageControl: (sensor: ReactiveSensor<any>) => sensor is ReactiveGarageControl;

export declare const isReactiveGasSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveGasSensor;

export declare const isReactiveHeatSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveHeatSensor;

export declare const isReactiveHumidityInfo: (sensor: ReactiveSensor<any>) => sensor is ReactiveHumidityInfo;

export declare const isReactiveIlluminanceInfo: (sensor: ReactiveSensor<any>) => sensor is ReactiveIlluminanceInfo;

export declare const isReactiveLeakSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveLeakSensor;

export declare const isReactiveLicensePlateSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveLicensePlateSensor;

export declare const isReactiveLightControl: (sensor: ReactiveSensor<any>) => sensor is ReactiveLightControl;

export declare const isReactiveLockControl: (sensor: ReactiveSensor<any>) => sensor is ReactiveLockControl;

export declare const isReactiveMotionSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveMotionSensor;

export declare const isReactiveObjectSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveObjectSensor;

export declare const isReactiveOccupancySensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveOccupancySensor;

export declare const isReactivePowerSensor: (sensor: ReactiveSensor<any>) => sensor is ReactivePowerSensor;

export declare const isReactiveProblemSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveProblemSensor;

export declare const isReactivePTZControl: (sensor: ReactiveSensor<any>) => sensor is ReactivePTZControl;

export declare const isReactiveSecuritySystem: (sensor: ReactiveSensor<any>) => sensor is ReactiveSecuritySystem;

export declare const isReactiveSirenControl: (sensor: ReactiveSensor<any>) => sensor is ReactiveSirenControl;

export declare const isReactiveSmokeSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveSmokeSensor;

export declare const isReactiveSwitchControl: (sensor: ReactiveSensor<any>) => sensor is ReactiveSwitchControl;

export declare const isReactiveTamperSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveTamperSensor;

export declare const isReactiveTemperatureInfo: (sensor: ReactiveSensor<any>) => sensor is ReactiveTemperatureInfo;

export declare const isReactiveVibrationSensor: (sensor: ReactiveSensor<any>) => sensor is ReactiveVibrationSensor;

/* Excluded from this release type: LeakProperty */

/* Excluded from this release type: LeakSensorProperties */

/* Excluded from this release type: LicensePlateProperty */

/* Excluded from this release type: LicensePlateSensorProperties */

/* Excluded from this release type: LightControlProperties */

/* Excluded from this release type: LightProperty */

/* Excluded from this release type: LockControlProperties */

/* Excluded from this release type: LockProperty */

/* Excluded from this release type: MotionProperty */

/* Excluded from this release type: MotionSensorProperties */

export declare class NamespaceManager {
    static coreManagerNamespaces(): CoreManagerNamespaces {
        return {
            coreManagerSubject: 'coreManager.subscriber',
            coreManagerRpc: 'coreManager.rpc',
        };
    }

    static deviceManagerNamespaces(): DeviceManagerNamespaces {
        return {
            deviceManagerSubject: 'deviceManager.subscriber',
            deviceManagerRpc: 'deviceManager.rpc',
        };
    }

    static sensorDiscoveryNamespaces(): SensorDiscoveryNamespaces {
        return {
            sensorDiscoverySubject: 'sensorDiscovery.subscriber',
        };
    }

    static discoveryManagerNamespaces(): DiscoveryManagerNamespaces {
        return {
            discoveryManagerSubject: 'discoveryManager.subscriber',
            discoveryManagerRpc: 'discoveryManager.rpc',
        };
    }

    static pluginNamespaces(pluginId: string): PluginNamespaces {
        return {
            pluginDeviceManagerSubject: `plugin.${pluginId}.deviceManager.subscriber`,
            pluginChildRpc: `plugin.${pluginId}.child.rpc`,
            pluginChild: `plugin.${pluginId}.child`,
            pluginStorageRpc: `plugin.${pluginId}.storage.rpc`,
            pluginConfigStoreRpc: `plugin.${pluginId}.configstore.rpc`,
        };
    }

    static pluginFileServeRpc(pluginId: string): string {
        return `plugin.${pluginId}.fileserve.rpc`;
    }

    static cameraNamespaces(cameraId: string): CameraNamespaces {
        return {
            cameraSubject: `camera.${cameraId}.subscriber`,
            cameraControllerRpc: `camera.${cameraId}.controller.rpc`,
        };
    }

    static frameWorkerNamespaces(cameraId: string): FrameWorkerNamespaces {
        return {
            frameWorkerChildRpc: `camera.${cameraId}.frameWorker.child.rpc`,
            frameWorkerChild: `camera.${cameraId}.frameWorker.child`,
        };
    }

    static pluginCameraNamespaces(pluginId: string, cameraId: string): PluginCameraNamespaces {
        return {
            cameraInterfacesRpc: `plugin.${pluginId}.camera.${cameraId}.cameraInterfaces.rpc`,
            cameraStorageRpc: `plugin.${pluginId}.camera.${cameraId}.cameraStorage.rpc`,
            cameraImplRpc: `plugin.${pluginId}.camera.${cameraId}.impl.rpc`,
        };
    }

    static pluginSensorNamespaces(pluginId: string, sensorId: string): PluginSensorNamespaces {
        return {
            sensorStorageRpc: `plugin.${pluginId}.sensor.${sensorId}.storage.rpc`,
        };
    }

    static sensorRegistryNamespaces(): SensorRegistryNamespaces {
        return {
            sensorsSubject: 'sensors.subject',
            sensorsRpc: 'sensors.rpc',
        };
    }

    static sensorCameraViewNamespaces(cameraId: string): SensorCameraViewNamespaces {
        return {
            sensorWriteSubject: `camera.${cameraId}.sensors.writes`,
        };
    }

    static sensorEventNamespaces(sensorId: string): SensorEventNamespaces {
        return {
            sensorSubject: `sensor.${sensorId}.subject`,
        };
    }

    static sensorProviderNamespaces(pluginId: string, sensorId: string): SensorProviderNamespaces {
        return {
            sensorRpc: `plugin.${pluginId}.sensor.${sensorId}.rpc`,
        };
    }

    static frameWorkerDetectionNamespaces(cameraId: string): FrameWorkerDetectionNamespaces {
        return {
            detectionRpc: `camera.${cameraId}.frameWorker.detection.rpc`,
        };
    }

    static detectionEventNamespaces(cameraId: string): DetectionEventNamespaces {
        return {
            detectionEventSubject: `camera.${cameraId}.events.subject`,
        };
    }

    static terminalManagerNamespaces(): TerminalManagerNamespaces {
        return {
            terminalManagerSubject: 'terminalManager.subscriber',
            terminalManagerRpc: 'terminalManager.rpc',
        };
    }

    static downloadManagerNamespaces(): DownloadManagerNamespaces {
        return {
            downloadManagerRpc: 'downloadManager.rpc',
        };
    }

    static notificationManagerNamespaces(): NotificationManagerNamespaces {
        return {
            notificationsPublishSubject: 'notifications.publish',
        };
    }

    static workerAgentRpc(agentId: string): string {
        return `worker.${agentId}.rpc`;
    }

    static workerManagerRpc(): string {
        return 'workers.manager.rpc';
    }

    static workerSync(agentId: string): string {
        return `worker.${agentId}.sync`;
    }

    static workerDisconnect(): string {
        return 'workers.disconnect';
    }

    static workerLogs(): string {
        return 'workers.logs';
    }
}

export { NatsStatus }

declare interface NotificationManagerNamespaces {
    notificationsPublishSubject: string;
}

/* Excluded from this release type: ObjectProperty */

/* Excluded from this release type: ObjectSensorProperties */

/* Excluded from this release type: OccupancyProperty */

/* Excluded from this release type: OccupancySensorProperties */

declare type PartialReturnType<T> = {
    [K in keyof T]: T[K] extends (...args: infer A) => Promise<infer R>
    ? (...args: A) => Promise<R | undefined>
    : T[K] extends (...args: infer A) => infer R
    ? (...args: A) => R | undefined
    : T[K];
};

export declare interface PluginCameraNamespaces {
    cameraInterfacesRpc: string;
    cameraStorageRpc: string;
    cameraImplRpc: string;
}

export declare interface PluginNamespaces {
    pluginDeviceManagerSubject: string;
    pluginChildRpc: string;
    pluginChild: string;
    pluginStorageRpc: string;
    pluginConfigStoreRpc: string;
}

export declare interface PluginSensorNamespaces {
    sensorStorageRpc: string;
}

/* Excluded from this release type: PowerProperty */

/* Excluded from this release type: PowerSensorProperties */

/* Excluded from this release type: ProblemProperty */

/* Excluded from this release type: ProblemSensorProperties */

/* Excluded from this release type: PTZControlProperties */

/* Excluded from this release type: PTZProperty */

export declare interface ReactiveAudioSensor extends ReactiveSensor<AudioSensorProperties> {
    readonly type: typeof SensorType.Audio;
    getProperty(property: typeof AudioProperty.Detected): boolean | undefined;
    getProperty(property: typeof AudioProperty.Detections): Detection[] | undefined;
    getProperty(property: typeof AudioProperty.Decibels): number | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveBatteryInfo extends ReactiveSensor<BatteryInfoProperties> {
    readonly type: typeof SensorType.Battery;
    getProperty(property: typeof BatteryProperty.Level): number | undefined;
    getProperty(property: typeof BatteryProperty.Low): boolean | undefined;
    getProperty(property: typeof BatteryProperty.Charging): ChargingState | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveCameraDevice {
    readonly id: string;
    readonly name: Ref<string>;
    readonly room: Ref<string>;
    readonly nativeId: Ref<string | undefined>;
    readonly disabled: Ref<boolean>;
    readonly snooze: Ref<boolean>;
    readonly isCloud: Ref<boolean>;
    readonly connected: Ref<boolean>;
    readonly frameWorkerConnected: Ref<boolean>;
    readonly sources: Ref<CameraSource[]>;
    readonly streamSource: Ref<CameraSource | undefined>;
    readonly snapshotSource: Ref<CameraSource | undefined>;
    readonly highResolutionSource: Ref<CameraSource | undefined>;
    readonly midResolutionSource: Ref<CameraSource | undefined>;
    readonly lowResolutionSource: Ref<CameraSource | undefined>;
    readonly capabilities: Ref<SensorType[]>;
    readonly hasLight: ComputedRef<boolean>;
    readonly hasSiren: ComputedRef<boolean>;
    readonly hasDoorbell: ComputedRef<boolean>;
    readonly hasBattery: ComputedRef<boolean>;
    readonly hasAudioSensor: ComputedRef<boolean>;
    readonly hasMotionSensor: ComputedRef<boolean>;
    readonly hasObjectSensor: ComputedRef<boolean>;
    readonly hasPtz: ComputedRef<boolean>;
    readonly camera: Ref<Camera>;
    readonly snapshot: ShallowRef<ArrayBuffer | undefined>;
    readonly snapshotLoading: Ref<boolean>;
    fetchSnapshot: (sourceId?: string, forceNew?: boolean) => Promise<ArrayBuffer | undefined>;
    probeStream: (sourceId?: string, probeConfig?: ProbeConfig, refresh?: boolean) => Promise<ProbeStream | undefined>;
    streamUrl: (sourceId: string) => Promise<string | undefined>;
    refreshStates: () => Promise<void>;
    reconnect: () => Promise<void>;
    close: () => Promise<void>;
}

declare interface ReactiveCameraDeviceContext {
    rpc: ShallowRef<RPCClient | undefined>;
}

export declare interface ReactiveCarbonDioxideInfo extends ReactiveSensor<CarbonDioxideInfoProperties> {
    readonly type: typeof SensorType.CarbonDioxide;
    getProperty(property: typeof CarbonDioxideProperty.Current): number | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveCarbonMonoxideSensor extends ReactiveSensor<CarbonMonoxideSensorProperties> {
    readonly type: typeof SensorType.CarbonMonoxide;
    getProperty(property: typeof CarbonMonoxideProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveClassifierSensor extends ReactiveSensor<ClassifierSensorProperties> {
    readonly type: typeof SensorType.Classifier;
    getProperty(property: typeof ClassifierProperty.Detected): boolean | undefined;
    getProperty(property: typeof ClassifierProperty.Detections): Detection[] | undefined;
    getProperty(property: typeof ClassifierProperty.Labels): string[] | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveColdSensor extends ReactiveSensor<ColdSensorProperties> {
    readonly type: typeof SensorType.Cold;
    getProperty(property: typeof ColdProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveContactSensor extends ReactiveSensor<ContactSensorProperties> {
    readonly type: typeof SensorType.Contact;
    getProperty(property: typeof ContactProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveCoreManager extends Omit<CoreManager, 'connectToPlugin' | 'signRequest' | 'onEvent' | 'assistantAsk' | 'assistantAccess'> {
}

export declare interface ReactiveDeviceManager {
    getCamera: (cameraIdOrName: string) => Promise<ReactiveCameraDevice | undefined>;
}

export declare interface ReactiveDoorbellTrigger extends ReactiveSensor<DoorbellTriggerProperties> {
    readonly type: typeof SensorType.Doorbell;
    getProperty(property: typeof DoorbellProperty.Ring): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveFaceSensor extends ReactiveSensor<FaceSensorProperties> {
    readonly type: typeof SensorType.Face;
    getProperty(property: typeof FaceProperty.Detected): boolean | undefined;
    getProperty(property: typeof FaceProperty.Detections): FaceDetection[] | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveGarageControl extends ReactiveSensor<GarageControlProperties> {
    readonly type: typeof SensorType.Garage;
    getProperty(property: typeof GarageProperty.CurrentState): GarageState | undefined;
    getProperty(property: typeof GarageProperty.TargetState): GarageState | undefined;
    getProperty(property: typeof GarageProperty.ObstructionDetected): boolean | undefined;
    getProperty(property: string): unknown;
    setProperty(property: typeof GarageProperty.TargetState, value: GarageState): Promise<void>;
    setProperty(property: string, value: unknown): Promise<void>;
}

export declare interface ReactiveGasSensor extends ReactiveSensor<GasSensorProperties> {
    readonly type: typeof SensorType.Gas;
    getProperty(property: typeof GasProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveHeatSensor extends ReactiveSensor<HeatSensorProperties> {
    readonly type: typeof SensorType.Heat;
    getProperty(property: typeof HeatProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveHumidityInfo extends ReactiveSensor<HumidityInfoProperties> {
    readonly type: typeof SensorType.Humidity;
    getProperty(property: typeof HumidityProperty.Current): number | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveIlluminanceInfo extends ReactiveSensor<IlluminanceInfoProperties> {
    readonly type: typeof SensorType.Illuminance;
    getProperty(property: typeof IlluminanceProperty.Current): number | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveLeakSensor extends ReactiveSensor<LeakSensorProperties> {
    readonly type: typeof SensorType.Leak;
    getProperty(property: typeof LeakProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveLicensePlateSensor extends ReactiveSensor<LicensePlateSensorProperties> {
    readonly type: typeof SensorType.LicensePlate;
    getProperty(property: typeof LicensePlateProperty.Detected): boolean | undefined;
    getProperty(property: typeof LicensePlateProperty.Detections): LicensePlateDetection[] | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveLightControl extends ReactiveSensor<LightControlProperties> {
    readonly type: typeof SensorType.Light;
    getProperty(property: typeof LightProperty.On): boolean | undefined;
    getProperty(property: typeof LightProperty.Brightness): number | undefined;
    getProperty(property: string): unknown;
    setProperty(property: typeof LightProperty.On, value: boolean): Promise<void>;
    setProperty(property: typeof LightProperty.Brightness, value: number): Promise<void>;
    setProperty(property: string, value: unknown): Promise<void>;
}

export declare interface ReactiveLockControl extends ReactiveSensor<LockControlProperties> {
    readonly type: typeof SensorType.Lock;
    getProperty(property: typeof LockProperty.CurrentState): LockState | undefined;
    getProperty(property: typeof LockProperty.TargetState): LockState | undefined;
    getProperty(property: string): unknown;
    setProperty(property: typeof LockProperty.CurrentState, value: LockState): Promise<void>;
    setProperty(property: typeof LockProperty.TargetState, value: LockState): Promise<void>;
    setProperty(property: string, value: unknown): Promise<void>;
}

export declare interface ReactiveMotionSensor extends ReactiveSensor<MotionSensorProperties> {
    readonly type: typeof SensorType.Motion;
    getProperty(property: typeof MotionProperty.Detected): boolean | undefined;
    getProperty(property: typeof MotionProperty.Detections): Detection[] | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveObjectSensor extends ReactiveSensor<ObjectSensorProperties> {
    readonly type: typeof SensorType.Object;
    getProperty(property: typeof ObjectProperty.Detected): boolean | undefined;
    getProperty(property: typeof ObjectProperty.Detections): Detection[] | undefined;
    getProperty(property: typeof ObjectProperty.Labels): string[] | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveOccupancySensor extends ReactiveSensor<OccupancySensorProperties> {
    readonly type: typeof SensorType.Occupancy;
    getProperty(property: typeof OccupancyProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactivePowerSensor extends ReactiveSensor<PowerSensorProperties> {
    readonly type: typeof SensorType.Power;
    getProperty(property: typeof PowerProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveProblemSensor extends ReactiveSensor<ProblemSensorProperties> {
    readonly type: typeof SensorType.Problem;
    getProperty(property: typeof ProblemProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactivePTZControl extends ReactiveSensor<PTZControlProperties> {
    readonly type: typeof SensorType.PTZ;
    getProperty(property: typeof PTZProperty.Position): PTZPosition | undefined;
    getProperty(property: typeof PTZProperty.Moving): boolean | undefined;
    getProperty(property: typeof PTZProperty.Presets): string[] | undefined;
    getProperty(property: typeof PTZProperty.Velocity): PTZDirection | undefined;
    getProperty(property: typeof PTZProperty.TargetPreset): string | undefined;
    getProperty(property: string): unknown;
    setProperty(property: typeof PTZProperty.Position, value: PTZPosition): Promise<void>;
    setProperty(property: typeof PTZProperty.Moving, value: boolean): Promise<void>;
    setProperty(property: typeof PTZProperty.Velocity, value: PTZDirection): Promise<void>;
    setProperty(property: typeof PTZProperty.TargetPreset, value: string): Promise<void>;
    setProperty(property: string, value: unknown): Promise<void>;
}

export declare interface ReactiveSecuritySystem extends ReactiveSensor<SecuritySystemProperties> {
    readonly type: typeof SensorType.SecuritySystem;
    getProperty(property: typeof SecuritySystemProperty.CurrentState): SecuritySystemState | undefined;
    getProperty(property: typeof SecuritySystemProperty.TargetState): SecuritySystemState | undefined;
    getProperty(property: string): unknown;
    setProperty(property: typeof SecuritySystemProperty.CurrentState, value: SecuritySystemState): Promise<void>;
    setProperty(property: typeof SecuritySystemProperty.TargetState, value: SecuritySystemState): Promise<void>;
    setProperty(property: string, value: unknown): Promise<void>;
}

export declare interface ReactiveSensor<TProperties extends object = Record<string, unknown>> {
    readonly id: string;
    readonly type: SensorType;
    readonly name: string;
    readonly displayName: Ref<string>;
    readonly nativeId?: string;
    readonly pluginId: string;
    readonly boundCameraId?: string;
    readonly assignedCameraIds: Ref<string[]>;
    readonly exposed: Ref<boolean>;
    readonly connected: Ref<boolean>;
    readonly capabilities: Ref<string[]>;
    readonly properties: TProperties;
    getProperty<T = unknown>(property: string): T | undefined;
    setProperty(property: string, value: unknown): Promise<void>;
    setDisplayName(displayName: string): Promise<void>;
    hasCapability(capability: string): boolean;
    onCapabilitiesChanged(callback: (capabilities: string[]) => void): () => void;
}

export declare interface ReactiveSensorManager {
    readonly sensors: ComputedRef<ReactiveSensor[]>;
    readonly isInitialized: ComputedRef<boolean>;
    ensureInitialized(): Promise<void>;
    reconnect(): Promise<void>;
    getSensor(sensorId: string): ReactiveSensor | undefined;
    getSensorsByType(type: SensorType): ReactiveSensor[];
    hasSensorType(type: SensorType): boolean;
    setDisplayName(sensorId: string, displayName: string): Promise<void>;
    close(): void;
}

export declare interface ReactiveSirenControl extends ReactiveSensor<SirenControlProperties> {
    readonly type: typeof SensorType.Siren;
    getProperty(property: typeof SirenProperty.Active): boolean | undefined;
    getProperty(property: typeof SirenProperty.Volume): number | undefined;
    getProperty(property: string): unknown;
    setProperty(property: typeof SirenProperty.Active, value: boolean): Promise<void>;
    setProperty(property: typeof SirenProperty.Volume, value: number): Promise<void>;
    setProperty(property: string, value: unknown): Promise<void>;
}

export declare interface ReactiveSmokeSensor extends ReactiveSensor<SmokeSensorProperties> {
    readonly type: typeof SensorType.Smoke;
    getProperty(property: typeof SmokeProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveStorage {
    readonly proxy: Promisify<StorageRPC>;
    readonly client: RPCClient;
    readonly config: ShallowRef<SchemaConfig | undefined>;
    readonly isLoading: Ref<boolean>;
    readonly error: Ref<Error | undefined>;
    getConfig(): Promise<SchemaConfig | undefined>;
    setValue<T = unknown>(key: string, value: T): Promise<void>;
    setConfig(newConfig: Record<string, unknown>): Promise<void>;
    submitValue(key: string, value: unknown): Promise<FormSubmitResponse | void>;
}

export declare interface ReactiveStream {
    readonly status: Ref<StreamStatus>;
    readonly activeMode: Ref<Exclude<VideoStreamingMode, 'auto'>>;
    readonly requestedMode: Ref<VideoStreamingMode>;
    readonly activeResolution: Ref<StreamingRole>;
    readonly requestedResolution: Ref<StreamingRole>;
    readonly degradedFrom: Ref<StreamingRole | null>;
    readonly degradeReason: Ref<StreamDegradeReason | null>;
    readonly source: Ref<CameraSource | undefined>;
    readonly hasVideo: Ref<boolean>;
    readonly hasAudio: Ref<boolean>;
    readonly hasBackchannel: Ref<boolean>;
    readonly isPlaying: Ref<boolean>;
    readonly error: Ref<Error | undefined>;
    readonly probeInfo: Ref<ProbeStream | undefined>;
    readonly muted: Ref<boolean>;
    readonly paused: Ref<boolean>;
    readonly nativeWidth: Ref<number>;
    readonly nativeHeight: Ref<number>;
    start: () => Promise<void>;
    stop: () => void;
    restart: () => Promise<void>;
    setMode: (mode: VideoStreamingMode) => Promise<void>;
    setResolution: (resolution: StreamingRole) => Promise<void>;
    setMicrophone: (track: MediaStreamTrack | null) => Promise<void>;
    setMuted: (muted: boolean) => void;
    play: () => Promise<void>;
    pause: () => void;
}

export declare interface ReactiveSwitchControl extends ReactiveSensor<SwitchControlProperties> {
    readonly type: typeof SensorType.Switch;
    getProperty(property: typeof SwitchProperty.On): boolean | undefined;
    getProperty(property: string): unknown;
    setProperty(property: typeof SwitchProperty.On, value: boolean): Promise<void>;
    setProperty(property: string, value: unknown): Promise<void>;
}

export declare interface ReactiveTamperSensor extends ReactiveSensor<TamperSensorProperties> {
    readonly type: typeof SensorType.Tamper;
    getProperty(property: typeof TamperProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveTemperatureInfo extends ReactiveSensor<TemperatureInfoProperties> {
    readonly type: typeof SensorType.Temperature;
    getProperty(property: typeof TemperatureProperty.Current): number | undefined;
    getProperty(property: string): unknown;
}

export declare interface ReactiveVibrationSensor extends ReactiveSensor<VibrationSensorProperties> {
    readonly type: typeof SensorType.Vibration;
    getProperty(property: typeof VibrationProperty.Detected): boolean | undefined;
    getProperty(property: string): unknown;
}

export declare function refreshClientSubscriptions(): void;

declare interface RefreshedStates {
    camera: Camera;
    cameraState: boolean;
    frameWorkerState: boolean;
    sensorStates: Record<string, SensorRefreshedState>;
}

export declare function releaseSensorManager(): void;

export declare function resetClientState(): void;

export declare function rpcCall<T>(rpcRef: Readonly<ShallowRef<RPCClient | undefined>>, fn: (rpc: RPCClient) => Promise<T>, options?: RpcCallOptions): Promise<T>;

export declare interface RpcCallOptions {
    maxRetries?: number;
    awaitConnect?: boolean;
    connectTimeoutMs?: number;
    retryDelayMs?: (attempt: number) => number;
    shouldRetry?: (err: unknown, attempt: number) => boolean;
    signal?: AbortSignal;
}

export { RPCClient }

/* Excluded from this release type: SecuritySystemProperties */

/* Excluded from this release type: SecuritySystemProperty */

declare interface SensorAddedEvent {
    sensor: StoredSensorData;
    state: SensorRefreshedState;
}

declare interface SensorAssignmentChangedEvent {
    sensorId: string;
    sensorType: SensorType;
    cameraId: string;
    assigned: boolean;
}

export declare interface SensorCameraViewNamespaces {
    sensorWriteSubject: string;
}

declare interface SensorCapabilitiesChangedEvent {
    sensorId: string;
    capabilities: string[];
}

declare interface SensorConnectedChangedEvent {
    sensorId: string;
    sensorType: SensorType;
    connected: boolean;
}

declare interface SensorDeletedEvent {
    sensorId: string;
    sensorType: SensorType;
}

declare interface SensorDiscoveryNamespaces {
    sensorDiscoverySubject: string;
}

declare interface SensorDisplayNameChangedEvent {
    sensorId: string;
    displayName: string;
}

export declare interface SensorEventMessage {
    type: 'property:changed' | 'sensor:added' | 'sensor:deleted' | 'sensor:connected:changed' | 'sensor:displayName:changed' | 'sensor:capabilities:changed' | 'sensor:assignment:changed' | 'sensor:exposed:changed';
    data: PropertyChangedEvent | SensorAddedEvent | SensorDeletedEvent | SensorConnectedChangedEvent | SensorDisplayNameChangedEvent | SensorCapabilitiesChangedEvent | SensorAssignmentChangedEvent | SensorExposedChangedEvent;
}

export declare interface SensorEventNamespaces {
    sensorSubject: string;
}

declare interface SensorExposedChangedEvent {
    sensorId: string;
    sensorType: SensorType;
    exposed: boolean;
    origin?: string;
}

export declare interface SensorProviderNamespaces {
    sensorRpc: string;
}

export declare interface SensorRefreshedState {
    type: SensorType;
    properties: Record<string, unknown>;
    capabilities: string[];
    displayName?: string;
}

export declare interface SensorRegistryNamespaces {
    sensorsSubject: string;
    sensorsRpc: string;
}

export declare interface SensorRegistryRPC {
    getSensors(): StoredSensorData[];
    getSensorRpc(sensorId: string): StoredSensorData | undefined;
    getSensorState(sensorId: string): SensorRefreshedState;
    getSensorStates(): Record<string, SensorRefreshedState>;
    getPropertyValue(sensorId: string, property: string): unknown;
    getAllPropertyValues(sensorId: string): Record<string, unknown>;
    setDisplayName(sensorId: string, displayName: string): void;
}

export declare function setFullscreenRoot(el: HTMLElement | null): void;

/* Excluded from this release type: SirenControlProperties */

/* Excluded from this release type: SirenProperty */

/* Excluded from this release type: SmokeProperty */

/* Excluded from this release type: SmokeSensorProperties */

declare interface SnapshotWithMeta {
    data: ArrayBuffer;
    ageMs: number;
}

export declare interface StorageRPC {
    getValue<T = string>(key: string, defaultValue?: T): Promise<T | undefined>;
    setValue<T = string>(key: string, newValue: T): Promise<void>;
    submitValue(key: string, newValue: unknown): Promise<FormSubmitResponse | void>;
    hasValue(key: string): boolean;
    getConfig(): Promise<SchemaConfig>;
    setConfig(newConfig: Record<string, unknown>): Promise<void>;
    getSchema<T>(key: string): T | undefined;
    hasSchema(key: string): boolean;
}

export declare interface StoredSensorData {
    id: string;
    type: SensorType;
    name: string;
    displayName: string;
    nativeId?: string;
    pluginId: string;
    assignedCameraIds: string[];
    boundCameraId?: string;
    exposed: boolean;
    origin?: string;
    address?: string;
    sourceState?: SensorSourceState;
    connected: boolean;
    properties: Record<string, unknown>;
    capabilities: string[];
    requiresFrames?: boolean;
    modelSpec?: ModelSpec;
}

export declare const STREAM_CONFIG: {
    readonly WEBRTC: {
        readonly RECONNECT_DELAY: 1000;
        readonly CONNECT_TIMEOUT: 10000;
        readonly WS_CONNECT_TIMEOUT: 5000;
        readonly ICE_SERVERS: readonly [{
            readonly urls: "stun:stun.l.google.com:19302";
        }];
    };
    readonly MSE: {
        readonly BUFFER_SIZE: number;
        readonly BUFFER_WINDOW: 5;
    };
    readonly CODECS: {
        readonly DEFAULT: readonly ["avc1.640029", "avc1.64002A", "avc1.640033", "hvc1.1.6.L153.B0", "mp4a.40.2", "mp4a.40.5", "flac", "opus"];
        readonly WEBRTC_VIDEO: readonly ["H264", "VP8", "VP9"];
        readonly WEBRTC_AUDIO: readonly ["opus", "G722", "PCMU", "PCMA"];
    };
};

declare type StreamDegradeReason = 'codec';

export declare interface StreamOptions {
    camera: MaybeRefOrGetter<ReactiveCameraDevice | undefined>;
    videoElement: MaybeRefOrGetter<HTMLVideoElement | undefined | null>;
    mode?: MaybeRefOrGetter<VideoStreamingMode>;
    resolution?: MaybeRefOrGetter<StreamingRole>;
    autoStart?: boolean;
    manageLifecycle?: boolean;
    wsReconnectTimeout?: number;
    webrtcConnectTimeout?: number;
}

export declare type StreamStatus = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'error' | 'unsupported' | 'closed';

/* Excluded from this release type: SwitchControlProperties */

/* Excluded from this release type: SwitchProperty */

/* Excluded from this release type: TamperProperty */

/* Excluded from this release type: TamperSensorProperties */

/* Excluded from this release type: TemperatureInfoProperties */

/* Excluded from this release type: TemperatureProperty */

export declare interface TerminalManagerInterface {
    createSession(options?: TerminalOptions): Promise<TerminalSessionInfo>;
    generateOutput(sessionId: string): AsyncGenerator<Uint8Array>;
    writeInput(sessionId: string, data: string): Promise<void>;
    resize(sessionId: string, dimensions: { cols: number; rows: number }): Promise<void>;
    closeSession(sessionId: string): Promise<void>;
}

export declare interface TerminalManagerNamespaces {
    terminalManagerSubject: string;
    terminalManagerRpc: string;
}

export declare interface TerminalOptions {
    cols?: number;
    rows?: number;
    cwd?: string;
    shell?: string;
    env?: Record<string, string>;
}

export declare interface TerminalSessionInfo {
    sessionId: string;
    pid: number;
    dimensions: { cols: number; rows: number };
}

declare interface TrainingCandidateBox {
    label: string;
    confidence: number;
    x: number;
    y: number;
    width: number;
    height: number;
}

declare interface TrainingCandidateIngest {
    cameraId: string;
    eventId: string;
    capturedAt: number;
    boxes: TrainingCandidateBox[];
    scene: Uint8Array;
}

declare type TrainingIngestResult = 'stored' | 'skip' | 'disabled';

export declare function useAllSensors(): UseSensorsReturn;

export declare function useAudioSensor(camera: CameraIdentifier, preferredPluginId?: MaybeRefOrGetter<string | undefined>): UseSensorTypedReturn<ReactiveAudioSensor>;

export declare function useCameraById(cameraIdOrName: MaybeRefOrGetter<string>): UseCameraByIdReturn;

export declare interface UseCameraByIdReturn {
    camera: ShallowRef<ReactiveCameraDevice | undefined>;
    isLoading: ComputedRef<boolean>;
    error: Ref<Error | undefined>;
    refresh: () => Promise<void>;
}

export declare function useCameraStorage(camera: CameraIdentifier, pluginName: MaybeRefOrGetter<string>): UseStorageReturn;

export declare function useCameraStream(options: UseCameraStreamOptions): CameraStream;

export declare interface UseCameraStreamOptions {
    camera: MaybeRefOrGetter<string | ReactiveCameraDevice>;
    mode?: MaybeRefOrGetter<VideoStreamingMode>;
    resolution?: MaybeRefOrGetter<StreamingRole>;
    activityMode?: MaybeRefOrGetter<CameraActivityMode>;
    activityConfig?: ActivityModeConfig;
    autoStart?: MaybeRefOrGetter<boolean>;
    startDelay?: number;
    isolated?: boolean;
    canvasStyle?: MaybeRefOrGetter<HTMLAttributes['style']>;
    canvasClass?: MaybeRefOrGetter<HTMLAttributes['class']>;
    videoStyle?: MaybeRefOrGetter<HTMLAttributes['style']>;
    videoClass?: MaybeRefOrGetter<HTMLAttributes['class']>;
}

export declare function useCameraUi(): CameraUiContext;

export declare function useClassifierSensors(camera: CameraIdentifier): UseSensorsTypedReturn<ReactiveClassifierSensor>;

export declare function useCoreManager(): ReactiveCoreManager;

export declare function useCuiFullscreen(target: MaybeRefOrGetter<HTMLElement | null | undefined>, options?: UseCuiFullscreenOptions): UseCuiFullscreenReturn;

export declare interface UseCuiFullscreenOptions {
    mode?: FullscreenMode;
}

export declare interface UseCuiFullscreenReturn {
    readonly isFullscreen: ComputedRef<boolean>;
    readonly isSupported: ComputedRef<boolean>;
    enter: () => Promise<void>;
    exit: () => Promise<void>;
    toggle: () => Promise<void>;
}

export declare function useDeviceManager(): ReactiveDeviceManager;

export declare function useFaceSensor(camera: CameraIdentifier, preferredPluginId?: MaybeRefOrGetter<string | undefined>): UseSensorTypedReturn<ReactiveFaceSensor>;

export declare function useLicensePlateSensor(camera: CameraIdentifier, preferredPluginId?: MaybeRefOrGetter<string | undefined>): UseSensorTypedReturn<ReactiveLicensePlateSensor>;

export declare function useMotionSensor(camera: CameraIdentifier, preferredPluginId?: MaybeRefOrGetter<string | undefined>): UseSensorTypedReturn<ReactiveMotionSensor>;

export declare function useOAuth(pluginName: string): UseOAuthReturn;

export declare interface UseOAuthReturn {
    readonly state: Ref<OAuthState>;
    readonly metadata: Ref<OAuthMetadata | null>;
    startDeviceFlow(scope: string[]): Promise<void>;
    startAuthCodeFlow(scope: string[]): Promise<void>;
    cancel(): Promise<void>;
    disconnect(): Promise<void>;
    refresh(): Promise<void>;
}

export declare function useObjectSensor(camera: CameraIdentifier, preferredPluginId?: MaybeRefOrGetter<string | undefined>): UseSensorTypedReturn<ReactiveObjectSensor>;

export declare function usePlugin(pluginName: MaybeRefOrGetter<string>): UsePluginReturn;

export declare interface UsePluginReturn {
    plugin: ShallowRef<Promisify<BasePlugin & PluginInterfaces> | undefined>;
    contract: Ref<PluginContract | undefined>;
    isLoading: ComputedRef<boolean>;
    error: Ref<Error | undefined>;
    refresh: () => Promise<void>;
}

export declare function usePluginStorage(pluginName: MaybeRefOrGetter<string>): UseStorageReturn;

export declare function usePTZControl(camera: CameraIdentifier): UseSensorTypedReturn<ReactivePTZControl>;

export declare function useRpcCall<T>(fn: (rpc: RPCClient) => Promise<T>, options?: UseRpcCallOptions): UseRpcCallReturn<T>;

export declare interface UseRpcCallOptions extends RpcCallOptions {
    immediate?: boolean;
    watch?: WatchSource[];
    refetchOnReconnect?: boolean;
}

export declare interface UseRpcCallReturn<T> {
    readonly data: ShallowRef<T | undefined>;
    readonly loading: Ref<boolean>;
    readonly error: Ref<Error | undefined>;
    execute(): Promise<T | undefined>;
    refresh(): Promise<T | undefined>;
}

export declare function useRpcSubscription(subscribeFn: (rpc: RPCClient) => Promise<() => void>, options?: UseRpcSubscriptionOptions): UseRpcSubscriptionReturn;

export declare interface UseRpcSubscriptionOptions {
    onError?: (err: unknown) => void;
    maxRetries?: number;
    retryDelayMs?: (attempt: number) => number;
}

export declare interface UseRpcSubscriptionReturn {
    readonly isActive: Ref<boolean>;
    resubscribe(): Promise<void>;
}

export declare function useSensorById(camera: CameraIdentifier, sensorId: MaybeRefOrGetter<string | undefined>): UseSensorReturn;

export declare function useSensorByType(camera: CameraIdentifier, sensorType: MaybeRefOrGetter<SensorType>): UseSensorReturn;

export declare interface UseSensorReturn {
    sensor: ShallowRef<ReactiveSensor<any> | undefined>;
    isLoading: ComputedRef<boolean>;
    error: Ref<Error | undefined>;
}

export declare function useSensors(camera: CameraIdentifier): UseSensorsReturn;

export declare function useSensorsByType(camera: CameraIdentifier, sensorType: MaybeRefOrGetter<SensorType>): UseSensorsReturn;

export declare interface UseSensorsReturn {
    sensors: ComputedRef<ReactiveSensor<any>[]>;
    isLoading: ComputedRef<boolean>;
    error: Ref<Error | undefined>;
}

export declare function useSensorStorage(sensorId: MaybeRefOrGetter<string | undefined>, pluginId: MaybeRefOrGetter<string | undefined>): UseStorageReturn;

export declare interface UseSensorsTypedReturn<T extends ReactiveSensor<any> = ReactiveSensor> {
    sensors: ComputedRef<T[]>;
    isLoading: ComputedRef<boolean>;
    error: Ref<Error | undefined>;
}

export declare interface UseSensorTypedReturn<T extends ReactiveSensor<any> = ReactiveSensor<any>> {
    sensor: ShallowRef<T | undefined>;
    isLoading: ComputedRef<boolean>;
    error: Ref<Error | undefined>;
}

export declare function useSnapshot(cameraIdOrName: MaybeRefOrGetter<string | DBCamera>): UseSnapshotReturn;

export declare interface UseSnapshotReturn {
    snapshot: ShallowRef<ArrayBuffer | undefined>;
    snapshotSrc: ComputedRef<string | undefined>;
    snapshotTimestamp: ComputedRef<number | undefined>;
    isLoading: ComputedRef<boolean>;
    refresh: () => Promise<void>;
}

export declare interface UseStorageReturn {
    config: ShallowRef<SchemaConfig | undefined>;
    isLoading: ComputedRef<boolean>;
    error: Ref<Error | undefined>;
    getConfig(): Promise<SchemaConfig | undefined>;
    setValue<T = unknown>(key: string, value: T): Promise<void>;
    setConfig(newConfig: Record<string, unknown>): Promise<void>;
    submitValue(key: string, value: unknown): Promise<FormSubmitResponse | void>;
    isConnected: Ref<boolean>;
}

export declare function useTabVisibility(): UseTabVisibilityReturn;

export declare interface UseTabVisibilityReturn {
    readonly isVisible: ComputedRef<boolean>;
    onTabHidden(cb: HiddenCallback): () => void;
    onTabPaused(cb: HiddenCallback, options?: {
        delayMs?: number;
    }): () => void;
    onTabVisible(cb: VisibleCallback): () => void;
}

export declare function useTerminal(): UseTerminalReturn;

export declare interface UseTerminalOptions extends TerminalOptions {
    onData?: (data: Uint8Array) => void;
    onClose?: () => void;
    onError?: (error: Error) => void;
}

export declare interface UseTerminalReturn {
    sessionId: Readonly<ShallowRef<string | undefined>>;
    isConnected: Readonly<Ref<boolean>>;
    isConnecting: Readonly<Ref<boolean>>;
    isClientConnected: Readonly<Ref<boolean>>;
    error: Readonly<Ref<Error | undefined>>;
    dimensions: Readonly<Ref<{
        cols: number;
        rows: number;
    }>>;
    connect: (options?: UseTerminalOptions) => Promise<void>;
    write: (data: string) => Promise<void>;
    resize: (dimensions: {
        cols: number;
        rows: number;
    }) => Promise<void>;
    close: () => Promise<void>;
}

export declare function useTopmostFullscreenElement(): ComputedRef<HTMLElement | null>;

/* Excluded from this release type: VibrationProperty */

/* Excluded from this release type: VibrationSensorProperties */

export declare type VideoStreamingMode = 'webrtc' | 'webrtc/tcp' | 'mse' | 'auto';

declare type VisibleCallback = (info: {
    hiddenMs: number;
}) => void;

export { }



declare module 'fastify' {
  interface FastifyRequest {
    locals: CustomLocals;
  }
  interface FastifyContextConfig {
    uploadToDisk?: boolean;
  }
}

/**
 * Copyright (c) 2017, Daniel Imms (MIT License).
 * Copyright (c) 2018, Microsoft Corporation (MIT License).
 */

declare module '@scrypted/node-pty' {
  /**
   * Forks a process as a pseudoterminal.
   * @param file The file to launch.
   * @param args The file's arguments as argv (string[]) or in a pre-escaped CommandLine format
   * (string). Note that the CommandLine option is only available on Windows and is expected to be
   * escaped properly.
   * @param options The options of the terminal.
   * @see CommandLineToArgvW https://msdn.microsoft.com/en-us/library/windows/desktop/bb776391(v=vs.85).aspx
   * @see Parsing C++ Comamnd-Line Arguments https://msdn.microsoft.com/en-us/library/17w5ykft.aspx
   * @see GetCommandLine https://msdn.microsoft.com/en-us/library/windows/desktop/ms683156.aspx
   */
  export function spawn(file: string, args: string[] | string, options: IPtyForkOptions | IWindowsPtyForkOptions): IPty;

  export interface IBasePtyForkOptions {
    /**
     * Name of the terminal to be set in environment ($TERM variable).
     */
    name?: string;

    /**
     * Number of intial cols of the pty.
     */
    cols?: number;

    /**
     * Number of initial rows of the pty.
     */
    rows?: number;

    /**
     * Working directory to be set for the child program.
     */
    cwd?: string;

    /**
     * Environment to be set for the child program.
     */
    env?: Record<string, string | undefined>;

    /**
     * String encoding of the underlying pty.
     * If set, incoming data will be decoded to strings and outgoing strings to bytes applying this encoding.
     * If unset, incoming data will be delivered as raw bytes (Buffer type).
     * By default 'utf8' is assumed, to unset it explicitly set it to `null`.
     */
    encoding?: string | null;

    /**
     * (EXPERIMENTAL)
     * Whether to enable flow control handling (false by default). If enabled a message of `flowControlPause`
     * will pause the socket and thus blocking the child program execution due to buffer back pressure.
     * A message of `flowControlResume` will resume the socket into flow mode.
     * For performance reasons only a single message as a whole will match (no message part matching).
     * If flow control is enabled the `flowControlPause` and `flowControlResume` messages are not forwarded to
     * the underlying pseudoterminal.
     */
    handleFlowControl?: boolean;

    /**
     * (EXPERIMENTAL)
     * The string that should pause the pty when `handleFlowControl` is true. Default is XOFF ('\x13').
     */
    flowControlPause?: string;

    /**
     * (EXPERIMENTAL)
     * The string that should resume the pty when `handleFlowControl` is true. Default is XON ('\x11').
     */
    flowControlResume?: string;
  }

  export interface IPtyForkOptions extends IBasePtyForkOptions {
    /**
     * Security warning: use this option with great caution,
     * as opened file descriptors with higher privileges might leak to the child program.
     */
    uid?: number;
    gid?: number;
  }

  export interface IWindowsPtyForkOptions extends IBasePtyForkOptions {
    /**
     * Whether to use the ConPTY system on Windows. When this is not set, ConPTY will be used when
     * the Windows build number is >= 18309 (instead of winpty). Note that ConPTY is available from
     * build 17134 but is too unstable to enable by default.
     *
     * This setting does nothing on non-Windows.
     */
    useConpty?: boolean;

    /**
     * Whether to use PSEUDOCONSOLE_INHERIT_CURSOR in conpty.
     * @see https://docs.microsoft.com/en-us/windows/console/createpseudoconsole
     */
    conptyInheritCursor?: boolean;
  }

  /**
   * An interface representing a pseudoterminal, on Windows this is emulated via the winpty library.
   */
  export interface IPty {
    /**
     * The process ID of the outer process.
     */
    readonly pid: number;

    /**
     * The column size in characters.
     */
    readonly cols: number;

    /**
     * The row size in characters.
     */
    readonly rows: number;

    /**
     * The title of the active process.
     */
    readonly process: string;

    /**
     * (EXPERIMENTAL)
     * Whether to handle flow control. Useful to disable/re-enable flow control during runtime.
     * Use this for binary data that is likely to contain the `flowControlPause` string by accident.
     */
    handleFlowControl: boolean;

    /**
     * Adds an event listener for when a data event fires. This happens when data is returned from
     * the pty.
     * @returns an `IDisposable` to stop listening.
     */
    readonly onData: IEvent<string>;

    /**
     * Adds an event listener for when an exit event fires. This happens when the pty exits.
     * @returns an `IDisposable` to stop listening.
     */
    readonly onExit: IEvent<{ exitCode: number; signal?: number }>;

    /**
     * Resizes the dimensions of the pty.
     * @param columns The number of columns to use.
     * @param rows The number of rows to use.
     */
    resize(columns: number, rows: number): void;

    /**
     * Clears the pty's internal representation of its buffer. This is a no-op
     * unless on Windows/ConPTY. This is useful if the buffer is cleared on the
     * frontend in order to synchronize state with the backend to avoid ConPTY
     * possibly reprinting the screen.
     */
    clear(): void;

    /**
     * Writes data to the pty.
     * @param data The data to write.
     */
    write(data: string): void;

    /**
     * Kills the pty.
     * @param signal The signal to use, defaults to SIGHUP. This parameter is not supported on
     * Windows.
     * @throws Will throw when signal is used on Windows.
     */
    kill(signal?: string): void;

    /**
     * Pauses the pty for customizable flow control.
     */
    pause(): void;

    /**
     * Resumes the pty for customizable flow control.
     */
    resume(): void;
  }

  /**
   * An object that can be disposed via a dispose function.
   */
  export interface IDisposable {
    dispose(): void;
  }

  /**
   * An event that can be listened to.
   * @returns an `IDisposable` to stop listening.
   */
  export type IEvent<T> = (listener: (e: T) => any) => IDisposable;
}