@apocaliss92/camstack-js-sdk 0.1.5

package/dist/index.d.ts

@@ -0,0 +1,759 @@
+/**
+ * SDK client configuration types.
+ *
+ * NVR types are now in nvr.ts (shared across app and proxy).
+ */
+interface HlsInfo {
+    hlsUrl: string;
+}
+/** Public provider info (returned by providers.list). */
+interface ProviderInfo {
+    id: string;
+    type: string;
+    name: string;
+}
+interface ProxyClientConfig {
+    proxyUrl: string;
+    /** Optional auth token for admin endpoints. */
+    token?: string;
+}
+interface DirectClientConfig {
+    directUrl: string;
+    type: "frigate";
+    username?: string;
+    password?: string;
+}
+type CamStackClientConfig = ProxyClientConfig | DirectClientConfig;
+declare function isProxyConfig(config: CamStackClientConfig): config is ProxyClientConfig;
+
+/**
+ * NVR types — system-agnostic types used by providers and the SDK client.
+ *
+ * These are the canonical types from the proxy's providers/types.ts,
+ * now owned by the SDK so both app and proxy can share them.
+ */
+interface StreamOption {
+    /** Unique identifier for this option (e.g. "auto", "cam_main", "mjpeg"). */
+    id: string;
+    /** Display label (e.g. "Auto", "High (WebRTC)", "MJPEG"). */
+    label: string;
+    /** Streaming technology. */
+    method: "webrtc" | "mjpeg";
+    /** go2rtc stream name (required for WebRTC). */
+    streamName?: string;
+}
+interface NvrCamera {
+    name: string;
+    /** Display label (may differ from internal name). */
+    label?: string;
+    enabled: boolean;
+    hasAudio: boolean;
+    hasPtz: boolean;
+    /** Available stream names for this camera (e.g. ["cam_main", "cam_sub"]). */
+    streams: string[];
+    /** Available streaming options with method and quality info. Always includes "Auto". */
+    streamOptions: StreamOption[];
+}
+interface StreamInfo {
+    name: string;
+    /** Camera this stream belongs to (if determinable). */
+    camera?: string;
+}
+/** Normalized bounding box in 0–1 range (provider-agnostic). */
+interface NormalizedBoundingBox {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+/** Detection data attached to an event. */
+interface DetectionData {
+    label: string;
+    subLabel?: string;
+    /** Confidence score 0–1. */
+    score: number;
+    /** Best confidence score observed during the event. */
+    topScore?: number;
+    /** Bounding box of the detected object, normalized 0–1. */
+    boundingBox?: NormalizedBoundingBox;
+    /** Detection region, normalized 0–1. */
+    region?: NormalizedBoundingBox;
+    /** Area as fraction of frame area (0–1). */
+    area?: number;
+    /** Named zones the object is currently in. */
+    currentZones?: string[];
+    /** Named zones the object has entered during this event. */
+    enteredZones?: string[];
+    /** Attributes detected (e.g., { face: 0.64, glasses: 0.82 }). */
+    attributes?: Record<string, number>;
+    /** Current estimated speed. */
+    currentSpeed?: number;
+    /** Average estimated speed over the event. */
+    averageSpeed?: number;
+    /** Velocity angle in degrees. */
+    velocityAngle?: number;
+    /** License plate recognition result. */
+    licensePlate?: {
+        text: string;
+        score: number;
+    };
+}
+/** Snapshot metadata associated with an event. */
+interface EventSnapshotData {
+    boundingBox?: NormalizedBoundingBox;
+    score?: number;
+    /** Area as fraction of frame area (0–1). */
+    area?: number;
+    attributes?: Record<string, number>;
+}
+interface NvrEvent {
+    id: string;
+    camera: string;
+    label: string;
+    startTime: number;
+    endTime: number | null;
+    severity?: string;
+    hasClip: boolean;
+    hasSnapshot: boolean;
+    thumbnailPath?: string;
+    snapshotPath?: string;
+    clipPath?: string;
+    detection?: DetectionData;
+    snapshot?: EventSnapshotData;
+    falsePositive?: boolean;
+    retainIndefinitely?: boolean;
+    raw?: Record<string, unknown>;
+}
+interface RecordingSegment {
+    id: string;
+    camera: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    motion?: number;
+    objects?: number;
+    dBFS?: number;
+}
+interface MotionBucket {
+    camera: string;
+    startTime: number;
+    motion?: number;
+    audio?: number;
+}
+type LiveEventType = "motion" | "detection" | "audio" | "event" | "review";
+interface LiveEvent {
+    type: LiveEventType;
+    camera: string;
+    timestamp: number;
+    data: Record<string, unknown>;
+}
+interface VideoClipsQuery {
+    camera: string;
+    after: number;
+    before: number;
+    limit?: number;
+    offset?: number;
+}
+interface NvrVideoClip {
+    id: string;
+    camera: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    label?: string;
+    hasClip: boolean;
+    hasSnapshot: boolean;
+    source: "event" | "recording";
+}
+interface VideoClipsResult {
+    clips: NvrVideoClip[];
+    total: number;
+}
+interface VideoClipUrlResult {
+    url: string;
+    mimeType: string;
+}
+interface CameraDayData {
+    events: NvrEvent[];
+    motion: MotionBucket[];
+    recordings: RecordingSegment[];
+}
+interface CameraStatus {
+    camera: string;
+    online: boolean;
+    recording: boolean;
+    detecting: boolean;
+    motionActive: boolean;
+}
+interface EventsQuery {
+    after?: number;
+    before?: number;
+    cameras?: string[];
+    limit?: number;
+    labels?: string[];
+}
+interface MotionQuery {
+    after: number;
+    before: number;
+    scale?: number;
+    cameras?: string[];
+}
+interface RecordingsQuery {
+    camera: string;
+    after: number;
+    before: number;
+}
+interface NvrConfig {
+    type: string;
+    version?: string;
+    raw?: unknown;
+}
+interface ProviderConfigs {
+    cameras: Array<{
+        id: string;
+        name: string;
+    }>;
+    enabledDetectionSources?: string[];
+}
+
+/**
+ * Timeline & event types — shared between CamStack app and proxy.
+ *
+ * Names are unified: the proxy's naming convention is canonical.
+ * The app re-exports aliases for backward compatibility where needed.
+ */
+/** Frigate severity: alert = notable, detection = regular. */
+type TimelineEventSeverity = "alert" | "detection";
+/** Motion fragment type: start/end from event boundaries, update from motion API. */
+type MotionFragmentType = "start" | "end" | "update";
+/**
+ * A detection event for timeline display and grouping.
+ * Unified from app's TimelineDetectionEvent and proxy's DetectionEvent.
+ */
+interface DetectionEvent {
+    id?: string;
+    timestamp: number;
+    source?: string;
+    classes?: string[];
+    /** @deprecated Use `classes` instead. Kept for backward compat with some app code. */
+    detectionClasses?: string[];
+    label?: string;
+    thumbnailUrl?: string;
+    imageUrl?: string;
+    videoUrl?: string;
+    gifUrl?: string;
+    severity?: TimelineEventSeverity;
+    deviceName?: string;
+    deviceId?: string;
+    ruleType?: string;
+    croppedThumbnailUrl?: string;
+    [key: string]: unknown;
+}
+/**
+ * Motion on/off item for timeline bar.
+ * Unified from app's TimelineMotionItem and proxy's MotionItem.
+ */
+interface MotionItem {
+    timestamp: number;
+    deviceId?: string;
+    motion: "on" | "off";
+    /** Fragment type or "motion" | "audio" (AN audio thresholds). */
+    type?: MotionFragmentType | "motion" | "audio" | string;
+    /** For type "audio": level 1–5 (threshold crossed). */
+    level?: number;
+    /** For type "audio": dBFS at threshold crossing. */
+    dBFS?: number;
+}
+/**
+ * Rule artifact for timeline (from Scrypted AN plugin rules).
+ * Unified from app's TimelineArtifactItem and proxy's TimelineArtifact.
+ */
+interface TimelineArtifact {
+    ruleName: string;
+    ruleType?: string;
+    timestamp: number;
+    imageUrl?: string;
+    gifUrl?: string;
+    videoUrl?: string;
+}
+/** Audio level segment for timeline bar. */
+interface AudioLevelSegment {
+    start: number;
+    end: number;
+    level: number;
+    dBFS?: number;
+}
+/** Recording segment for timeline bar (where recording exists). */
+interface TimelineRecordingSegment {
+    start: number;
+    end: number;
+}
+/** Day data for timeline (events, motion, artifacts). */
+interface CameraDayDataResponse {
+    events: DetectionEvent[];
+    motion: MotionItem[];
+    artifacts: TimelineArtifact[];
+    recordings?: TimelineRecordingSegment[];
+}
+/** Clustered day data response (server-side bucketing). */
+interface ClusteredDayDataResponse {
+    clusters: TimelineCluster[];
+    motion: MotionItem[];
+    artifacts: TimelineArtifact[];
+    motionSegments?: TimelineRecordingSegment[];
+    audioLevelSegments?: AudioLevelSegment[];
+    recordings?: TimelineRecordingSegment[];
+}
+/** A time-bucketed cluster of detection events. */
+interface TimelineCluster {
+    events: DetectionEvent[];
+    representative: DetectionEvent;
+    classes: string[];
+    labels: string[];
+    startMs: number;
+    endMs: number;
+}
+/** A group of related detection events with a representative. */
+interface DetectionGroup {
+    events: DetectionEvent[];
+    representative: DetectionEvent;
+    classes: string[];
+    labels: string[];
+}
+/** Query for clustered day data. */
+interface ClusteredDayDataQuery {
+    camera: string;
+    days: string[];
+    bucketMs?: number;
+    enabledClasses?: string[];
+    classFilter?: string;
+}
+/** Query for grouped events. */
+interface GroupedEventsQuery {
+    after?: number;
+    before?: number;
+    limit?: number;
+    offset?: number;
+    cameras?: string[];
+    detectionClasses?: string[];
+    eventSource?: string;
+    filter?: string;
+    groupingRange?: number;
+}
+/** Result of grouped events query. */
+interface GroupedEventsResult {
+    groups: DetectionGroup[];
+    total: number;
+    ruleArtifacts?: DetectionGroup[];
+}
+/** Query for events within a cluster time range. */
+interface ClusterEventsQuery {
+    camera: string;
+    startMs: number;
+    endMs: number;
+}
+/** Result of cluster events query. */
+interface ClusterEventsResult {
+    events: DetectionEvent[];
+}
+/** A reel event (carousel-friendly). */
+interface ReelEvent {
+    id: string;
+    camera: string;
+    cameraName: string;
+    label: string;
+    startTime: number;
+    thumbnail?: string;
+    croppedThumbnailUrl?: string;
+    hasClip?: boolean;
+    gifUrl?: string;
+    videoUrl?: string;
+    imageUrl?: string;
+    classes?: string[];
+}
+/** Query for reel events. */
+interface ReelEventsQuery {
+    limit?: number;
+    offset?: number;
+    cameras?: string[];
+    eventSource?: string;
+    detectionClasses?: string[];
+}
+/** Result of reel events query. */
+interface ReelEventsResult {
+    events: ReelEvent[];
+    total: number;
+}
+/** @deprecated Use DetectionEvent instead. */
+type TimelineDetectionEvent = DetectionEvent;
+/** @deprecated Use MotionItem instead. */
+type TimelineMotionItem = MotionItem;
+/** @deprecated Use TimelineArtifact instead. */
+type TimelineArtifactItem = TimelineArtifact;
+/** @deprecated Use TimelineCluster instead. */
+type TimelineClusterFromServer = TimelineCluster;
+
+/**
+ * CamStackClient — unified API, dual mode (proxy or direct).
+ *
+ * Usage:
+ *   const client = createCamStackClient({ proxyUrl: 'http://localhost:4000' });
+ *   const client = createCamStackClient({ directUrl: 'http://frigate:5000', type: 'frigate' });
+ */
+
+declare class CamStackClient {
+    private proxy;
+    private direct;
+    readonly isProxy: boolean;
+    constructor(config: CamStackClientConfig);
+    listProviders(): Promise<ProviderInfo[]>;
+    getConfig(providerId?: string): Promise<NvrConfig>;
+    getStreams(providerId?: string): Promise<StreamInfo[]>;
+    listCameras(providerId?: string): Promise<NvrCamera[]>;
+    getSnapshot(camera: string, providerId?: string): Promise<string>;
+    getEvents(params: EventsQuery & {
+        providerId?: string;
+    }): Promise<NvrEvent[]>;
+    getRecordings(params: RecordingsQuery & {
+        providerId?: string;
+    }): Promise<RecordingSegment[]>;
+    getMotionActivity(params: MotionQuery & {
+        providerId?: string;
+    }): Promise<MotionBucket[]>;
+    getAudioSegments(camera: string, after: number, before: number, providerId?: string): Promise<AudioLevelSegment[]>;
+    getEventThumbnail(eventId: string, providerId?: string): Promise<string>;
+    getEventSnapshot(eventId: string, providerId?: string): Promise<string>;
+    webrtcOffer(streamName: string, sdpOffer: string, providerId?: string): Promise<string>;
+    getRecordingHlsUrl(camera: string, startTime: number, endTime: number, providerId?: string): Promise<string>;
+    getEventHlsUrl(eventId: string, providerId?: string): Promise<string>;
+    subscribeLiveEvents(callback: (event: LiveEvent) => void, options?: {
+        cameras?: string[];
+        types?: string[];
+        providerId?: string;
+    }): {
+        unsubscribe: () => void;
+    };
+    subscribeMotion(camera: string, callback: (event: LiveEvent) => void, providerId?: string): {
+        unsubscribe: () => void;
+    };
+    subscribeDetection(camera: string, callback: (event: LiveEvent) => void, providerId?: string): {
+        unsubscribe: () => void;
+    };
+    subscribeAudioLevel(camera: string, callback: (event: LiveEvent) => void, providerId?: string): {
+        unsubscribe: () => void;
+    };
+}
+declare function createCamStackClient(config: CamStackClientConfig): CamStackClient;
+
+/**
+ * Proxy client — connects to camstack-js-proxy via tRPC.
+ * Full features: queries, mutations, subscriptions, WebRTC, HLS.
+ */
+
+declare class ProxyClient {
+    private trpc;
+    private baseUrl;
+    constructor(config: ProxyClientConfig);
+    listProviders(): Promise<ProviderInfo[]>;
+    getConfig(providerId?: string): Promise<NvrConfig>;
+    getStreams(providerId?: string): Promise<StreamInfo[]>;
+    listCameras(providerId?: string): Promise<NvrCamera[]>;
+    getSnapshot(camera: string, providerId?: string): Promise<string>;
+    getEvents(params: EventsQuery & {
+        providerId?: string;
+    }): Promise<NvrEvent[]>;
+    getRecordings(params: RecordingsQuery & {
+        providerId?: string;
+    }): Promise<RecordingSegment[]>;
+    getMotionActivity(params: MotionQuery & {
+        providerId?: string;
+    }): Promise<MotionBucket[]>;
+    getAudioSegments(camera: string, after: number, before: number, providerId?: string): Promise<AudioLevelSegment[]>;
+    getEventThumbnail(eventId: string, providerId?: string): Promise<string>;
+    getEventSnapshot(eventId: string, providerId?: string): Promise<string>;
+    webrtcOffer(streamName: string, sdpOffer: string, providerId?: string): Promise<string>;
+    getRecordingHls(camera: string, startTime: number, endTime: number, providerId?: string): Promise<string>;
+    getEventHls(eventId: string, providerId?: string): Promise<string>;
+    subscribeLiveEvents(callback: (event: LiveEvent) => void, options?: {
+        cameras?: string[];
+        types?: string[];
+        providerId?: string;
+        onError?: (err: unknown) => void;
+        onStarted?: () => void;
+        onStopped?: () => void;
+    }): {
+        unsubscribe: () => void;
+    };
+    subscribeMotion(camera: string, callback: (event: LiveEvent) => void, providerId?: string): {
+        unsubscribe: () => void;
+    };
+    subscribeDetection(camera: string, callback: (event: LiveEvent) => void, providerId?: string): {
+        unsubscribe: () => void;
+    };
+    subscribeAudioLevel(camera: string, callback: (event: LiveEvent) => void, providerId?: string): {
+        unsubscribe: () => void;
+    };
+}
+
+/**
+ * Direct client — connects to NVR HTTP API without a proxy.
+ * Limited functionality: queries only, no subscriptions, no audio tracking.
+ */
+
+declare class DirectClient {
+    private baseUrl;
+    private type;
+    private username?;
+    private password?;
+    private token;
+    constructor(config: DirectClientConfig);
+    private authHeaders;
+    private request;
+    getConfig(): Promise<NvrConfig>;
+    getStreams(): Promise<StreamInfo[]>;
+    listCameras(): Promise<NvrCamera[]>;
+    getSnapshot(camera: string): Promise<string>;
+    getEvents(params: EventsQuery): Promise<NvrEvent[]>;
+    getRecordings(params: RecordingsQuery): Promise<RecordingSegment[]>;
+    getMotionActivity(params: MotionQuery): Promise<MotionBucket[]>;
+    /** Audio segments are not available in direct mode (tracked by proxy only). */
+    getAudioSegments(_camera: string, _after: number, _before: number): Promise<AudioLevelSegment[]>;
+    getEventThumbnail(eventId: string): Promise<string>;
+    getEventSnapshot(eventId: string): Promise<string>;
+    webrtcOffer(streamName: string, sdpOffer: string): Promise<string>;
+    getRecordingHlsUrl(camera: string, startTime: number, endTime: number): string;
+    getEventHlsUrl(eventId: string): string;
+}
+
+/**
+ * Detection classes — shared between CamStack app and proxy.
+ * Aligned with scrypted-advanced-notifier/src/detectionClasses.ts.
+ */
+declare enum DetectionClass {
+    Motion = "motion",
+    Person = "person",
+    Vehicle = "vehicle",
+    Animal = "animal",
+    Audio = "audio",
+    Face = "face",
+    Plate = "plate",
+    Package = "package",
+    Doorbell = "doorbell",
+    Sensor = "sensor"
+}
+declare const animalClasses: string[];
+declare const personClasses: string[];
+declare const vehicleClasses: string[];
+declare const faceClasses: string[];
+declare const licensePlateClasses: string[];
+declare const motionClasses: string[];
+declare const packageClasses: string[];
+declare const audioClasses: string[];
+/** Common YAMNet audio labels (advanced-notifier). Parent: Audio. */
+declare const audioLabelClasses: string[];
+declare const doorbellClasses: string[];
+/** Sensor types (advanced-notifier SupportedSensorType). Parent: Sensor. */
+declare const sensorLabelClasses: string[];
+declare const detectionClassesDefaultMap: Record<string, DetectionClass>;
+declare const isFaceClassname: (c: string) => boolean;
+declare const isPlateClassname: (c: string) => boolean;
+declare const isAnimalClassname: (c: string) => boolean;
+declare const isPersonClassname: (c: string) => boolean;
+declare const isVehicleClassname: (c: string) => boolean;
+declare const isMotionClassname: (c: string) => boolean;
+declare const isDoorbellClassname: (c: string) => boolean;
+declare const isPackageClassname: (c: string) => boolean;
+declare const isAudioClassname: (c: string) => boolean;
+declare const isSensorLabelClassname: (c: string) => boolean;
+declare const isLabelDetection: (c: string) => boolean;
+declare const getParentClass: (className: string) => DetectionClass | undefined;
+declare const getParentDetectionClass: (det: {
+    label?: string;
+    className: string;
+}) => DetectionClass | undefined;
+declare const defaultDetectionClasses: DetectionClass[];
+/** Default enabled classes: all except Motion. */
+declare const DEFAULT_ENABLED_CLASSES: (DetectionClass.Person | DetectionClass.Vehicle | DetectionClass.Animal | DetectionClass.Audio | DetectionClass.Face | DetectionClass.Plate | DetectionClass.Package | DetectionClass.Doorbell | DetectionClass.Sensor)[];
+type TimelineEventPreset = "all" | "important" | "critical" | "custom";
+/** Classes for "critical" preset: security-relevant only (person, doorbell, package). */
+declare const TIMELINE_PRESET_CRITICAL: string[];
+/** Classes for "important" preset: critical + vehicle, animal, audio, face, plate. */
+declare const TIMELINE_PRESET_IMPORTANT: string[];
+/** Classes for "all" preset: same as DEFAULT_ENABLED_CLASSES. */
+declare const TIMELINE_PRESET_ALL: string[];
+/** Get enabled classes for a preset. For "custom", pass customClasses. */
+declare function getClassesForTimelinePreset(preset: TimelineEventPreset, customClasses?: string[]): string[];
+
+/**
+ * Device types, mappings, and filtering constants — shared between CamStack app and proxy.
+ *
+ * Covers:
+ * - Canonical device type normalization (Scrypted PascalCase + HA domains → canonical)
+ * - Eligible device type lists for Scrypted and Home Assistant
+ * - Unified Device / DeviceCommand / CommandResult interfaces
+ * - AssociatedDeviceState shape
+ */
+type CanonicalDeviceType = "light" | "switch" | "cover" | "lock" | "alarm" | "button" | "select" | "siren" | "sensor" | "entry" | "media_player" | "script";
+/**
+ * Maps raw device types from Scrypted (PascalCase) and Home Assistant (lowercase domains)
+ * to canonical CamStack device types.
+ */
+declare const RAW_TO_CANONICAL: Record<string, CanonicalDeviceType>;
+/**
+ * Extended HA domain → type map (includes non-eligible domains for display/categorization).
+ * Superset of RAW_TO_CANONICAL for HA-specific domains.
+ */
+declare const HA_DOMAIN_TYPE_MAP: Record<string, string>;
+/**
+ * Extended Scrypted type → canonical map (includes non-eligible types for display).
+ * Superset of RAW_TO_CANONICAL for Scrypted-specific types.
+ */
+declare const SCRYPTED_TYPE_TO_CANONICAL: Record<string, string>;
+/** Normalize raw type (Scrypted or HA) to canonical key for filtering and display. */
+declare function getCanonicalDeviceType(rawType: string): CanonicalDeviceType | null;
+/** Scrypted device types eligible for device control in CamStack. PascalCase. */
+declare const ELIGIBLE_SCRYPTED_DEVICE_TYPES: readonly ["Entry", "Light", "Switch", "Lock", "SecuritySystem", "Buttons", "WindowCovering", "Siren", "Sensor", "Select", "Program"];
+/** Set version for O(1) lookup. */
+declare const ELIGIBLE_SCRYPTED_DEVICE_TYPES_SET: Set<string>;
+/** Home Assistant domains eligible for device control in CamStack. */
+declare const ELIGIBLE_HA_DOMAINS: readonly ["light", "switch", "input_boolean", "cover", "lock", "alarm_control_panel", "input_button", "button", "input_select", "select", "siren", "media_player", "script"];
+/** Set version for O(1) lookup. */
+declare const ELIGIBLE_HA_DOMAINS_SET: Set<string>;
+/** All device command actions supported by CamStack. */
+type DeviceCommandAction = "turnOn" | "turnOff" | "openEntry" | "closeEntry" | "stopEntry" | "lock" | "unlock" | "disarm" | "arm" | "pressButton" | "selectOption" | "volumeUp" | "volumeDown" | "volumeMute";
+/**
+ * State snapshot shape for an associated device.
+ * Used by both app (AssociatedDeviceStateSnapshot) and proxy (Device.state).
+ */
+interface AssociatedDeviceState {
+    name?: string;
+    type?: string;
+    interfaces?: string[];
+    on?: boolean;
+    hasBrightnessControl?: boolean;
+    brightness?: number;
+    lockState?: string;
+    securitySystemState?: {
+        mode?: string;
+        supportedModes?: string[];
+    };
+    buttons?: string[];
+    entryOpen?: boolean | "jammed";
+    value?: string;
+    options?: string[];
+    volumeLevel?: number;
+    isVolumeMuted?: boolean;
+    coverSupportsStop?: boolean;
+    coverPosition?: number;
+}
+/** A device from an automation system (Scrypted, Home Assistant, etc.). */
+interface Device {
+    id: string;
+    name: string;
+    /**
+     * Canonical device type (lowercase): "light", "switch", "cover", "lock",
+     * "alarm", "button", "select", "siren", "sensor", "entry", "media_player", "script".
+     */
+    type: string;
+    /** Original type from the source system (e.g. Scrypted "WindowCovering", HA domain "cover"). */
+    rawType?: string;
+    model?: string;
+    manufacturer?: string;
+    online: boolean;
+    interfaces: string[];
+    /** Current state (key-value pairs, device-type-dependent). See AssociatedDeviceState. */
+    state: Record<string, unknown>;
+}
+/** A command to send to a device. */
+interface DeviceCommand {
+    deviceId: string;
+    command: string;
+    params?: Record<string, unknown>;
+}
+/** Result of a command execution. */
+interface CommandResult {
+    success: boolean;
+    error?: string;
+    state?: Record<string, unknown>;
+}
+/** Device source type (integration that provides the device). */
+type AssociatedDeviceSource = "scrypted" | "ha";
+/** Eligible device summary (for device picker UI). */
+interface EligibleDevice {
+    id: string;
+    name: string;
+    type: string;
+    source: AssociatedDeviceSource;
+}
+
+/**
+ * Camera & PTZ types — shared between CamStack app and proxy.
+ */
+/** Camera source type discriminator. */
+type CameraSourceType = "scrypted" | "frigate" | "onvif" | "rtsp";
+/** Streaming method. */
+type StreamMethod = "webrtc" | "mjpeg";
+/** Scrypted-compatible PTZ command. */
+interface PanTiltZoomCommand {
+    movement?: "Relative" | "Absolute" | "Continuous" | "Home" | "Preset";
+    pan?: number;
+    tilt?: number;
+    zoom?: number;
+    preset?: string;
+    timeout?: number;
+}
+/** PTZ capabilities reported by the device. */
+interface PanTiltZoomCapabilities {
+    pan?: boolean;
+    tilt?: boolean;
+    zoom?: boolean;
+    presets?: Record<string, string>;
+}
+/** Accessory switch kinds exposed by the Advanced Notifier plugin. */
+type CameraAccessorySwitchKind = "siren_on_motion" | "siren" | "light_on_motion" | "light" | "pir" | "autotracking";
+/** Extended camera status with accessory switches (from AN plugin). */
+interface CameraStatusEntry {
+    notificationsEnabled: boolean;
+    isRecording: boolean;
+    isSnapshotsEnabled: boolean;
+    isRebroadcastEnabled: boolean;
+    accessorySwitchStates: Partial<Record<CameraAccessorySwitchKind, boolean>>;
+}
+/** Batch camera status response. */
+interface CamerasStatusResult {
+    cameras: Record<string, CameraStatusEntry>;
+}
+
+/**
+ * Feature capability matrix — shared between CamStack app and proxy.
+ *
+ * Maps each app feature to:
+ * - Which source types (Frigate, Scrypted, RTSP) support it
+ * - Which platforms (iOS, Android, Web, Scrypted embed) it works on
+ * - Whether the camstack-js-proxy backend is required
+ * - The ICameraSource method that enables the feature
+ */
+type FeatureId = "liveStream" | "multiResolution" | "motion" | "objectDetection" | "audioVolume" | "audioVolumes" | "ptz" | "intercom" | "deviceStatus" | "timeline" | "clusteredTimeline" | "detectionClasses" | "videoClips" | "nvrPlayback" | "nvrScrub" | "recordingThumbnail" | "nvrSeekToLive";
+type PlatformId = "ios" | "android" | "web" | "scryptedEmbed";
+type SourceType = "frigate" | "scrypted" | "rtsp";
+interface FeatureEntry {
+    id: FeatureId;
+    label: string;
+    /** Which source types support this feature. */
+    sources: Partial<Record<SourceType, boolean>>;
+    /** Platform availability overrides. When omitted, all platforms are supported. */
+    platforms?: Partial<Record<PlatformId, boolean>>;
+    /** True when this feature needs the camstack-js-proxy backend. */
+    requiresBackend?: boolean;
+    /** The ICameraSource method name that enables this feature at runtime. */
+    adapterMethod?: string;
+}
+declare const FEATURE_MATRIX: FeatureEntry[];
+/** Check if a feature is available for a given source type and platform. */
+declare function isFeatureAvailable(featureId: FeatureId, source: SourceType, platform: PlatformId): boolean;
+/** Get all features supported by a source type. */
+declare function getSourceFeatures(source: SourceType): FeatureEntry[];
+/** Get all features that require the backend proxy. */
+declare function getBackendRequiredFeatures(): FeatureEntry[];
+
+export { type AssociatedDeviceSource, type AssociatedDeviceState, type AudioLevelSegment, CamStackClient, type CamStackClientConfig, type CameraAccessorySwitchKind, type CameraDayData, type CameraDayDataResponse, type CameraSourceType, type CameraStatus, type CameraStatusEntry, type CamerasStatusResult, type CanonicalDeviceType, type ClusterEventsQuery, type ClusterEventsResult, type ClusteredDayDataQuery, type ClusteredDayDataResponse, type CommandResult, DEFAULT_ENABLED_CLASSES, DetectionClass, type DetectionData, type DetectionEvent, type DetectionGroup, type Device, type DeviceCommand, type DeviceCommandAction, DirectClient, type DirectClientConfig, ELIGIBLE_HA_DOMAINS, ELIGIBLE_HA_DOMAINS_SET, ELIGIBLE_SCRYPTED_DEVICE_TYPES, ELIGIBLE_SCRYPTED_DEVICE_TYPES_SET, type EligibleDevice, type EventSnapshotData, type EventsQuery, FEATURE_MATRIX, type FeatureEntry, type FeatureId, type GroupedEventsQuery, type GroupedEventsResult, HA_DOMAIN_TYPE_MAP, type HlsInfo, type LiveEvent, type LiveEventType, type MotionBucket, type MotionFragmentType, type MotionItem, type MotionQuery, type NormalizedBoundingBox, type NvrCamera, type NvrConfig, type NvrEvent, type NvrVideoClip, type PanTiltZoomCapabilities, type PanTiltZoomCommand, type PlatformId, type ProviderConfigs, type ProviderInfo, ProxyClient, type ProxyClientConfig, RAW_TO_CANONICAL, type RecordingSegment, type RecordingsQuery, type ReelEvent, type ReelEventsQuery, type ReelEventsResult, SCRYPTED_TYPE_TO_CANONICAL, type SourceType, type StreamInfo, type StreamMethod, type StreamOption, TIMELINE_PRESET_ALL, TIMELINE_PRESET_CRITICAL, TIMELINE_PRESET_IMPORTANT, type TimelineArtifact, type TimelineArtifactItem, type TimelineCluster, type TimelineClusterFromServer, type TimelineDetectionEvent, type TimelineEventPreset, type TimelineEventSeverity, type TimelineMotionItem, type TimelineRecordingSegment, type VideoClipUrlResult, type VideoClipsQuery, type VideoClipsResult, animalClasses, audioClasses, audioLabelClasses, createCamStackClient, defaultDetectionClasses, detectionClassesDefaultMap, doorbellClasses, faceClasses, getBackendRequiredFeatures, getCanonicalDeviceType, getClassesForTimelinePreset, getParentClass, getParentDetectionClass, getSourceFeatures, isAnimalClassname, isAudioClassname, isDoorbellClassname, isFaceClassname, isFeatureAvailable, isLabelDetection, isMotionClassname, isPackageClassname, isPersonClassname, isPlateClassname, isProxyConfig, isSensorLabelClassname, isVehicleClassname, licensePlateClasses, motionClasses, packageClasses, personClasses, sensorLabelClasses, vehicleClasses };