@apocaliss92/camstack-js-sdk 0.1.5

package/dist/index.js

@@ -0,0 +1,995 @@
+// src/proxy-client.ts
+import {
+  createTRPCClient,
+  httpBatchLink,
+  splitLink,
+  createWSClient,
+  wsLink
+} from "@trpc/client";
+import superjson from "superjson";
+var ProxyClient = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  trpc;
+  baseUrl;
+  constructor(config) {
+    this.baseUrl = config.proxyUrl.replace(/\/+$/, "");
+    const trpcUrl = `${this.baseUrl}/trpc`;
+    const headers = {};
+    if (config.token) {
+      headers["Authorization"] = `Bearer ${config.token}`;
+    }
+    const wsProtocol = this.baseUrl.startsWith("https") ? "wss" : "ws";
+    const wsHost = this.baseUrl.replace(/^https?:\/\//, "");
+    const wsUrl = config.token ? `${wsProtocol}://${wsHost}/trpc?token=${encodeURIComponent(config.token)}` : `${wsProtocol}://${wsHost}/trpc`;
+    const wsClient = createWSClient({ url: wsUrl });
+    this.trpc = createTRPCClient({
+      links: [
+        splitLink({
+          condition: (op) => op.type === "subscription",
+          true: wsLink({ client: wsClient, transformer: superjson }),
+          false: httpBatchLink({
+            url: trpcUrl,
+            transformer: superjson,
+            headers
+          })
+        })
+      ]
+    });
+  }
+  // ─── Providers ───────────────────────────────────────────────────
+  async listProviders() {
+    return this.trpc.providers.list.query();
+  }
+  // ─── Config ────────────────────────────────────────────────────
+  async getConfig(providerId) {
+    return this.trpc.config.getConfig.query({ providerId });
+  }
+  async getStreams(providerId) {
+    return this.trpc.config.getStreams.query({ providerId });
+  }
+  // ─── Cameras ───────────────────────────────────────────────────
+  async listCameras(providerId) {
+    return this.trpc.cameras.list.query({ providerId });
+  }
+  async getSnapshot(camera, providerId) {
+    return this.trpc.cameras.getSnapshot.query({ camera, providerId });
+  }
+  // ─── Events ────────────────────────────────────────────────────
+  async getEvents(params) {
+    return this.trpc.events.list.query(params);
+  }
+  async getRecordings(params) {
+    return this.trpc.events.getRecordings.query(params);
+  }
+  async getMotionActivity(params) {
+    return this.trpc.events.getMotionActivity.query(params);
+  }
+  async getAudioSegments(camera, after, before, providerId) {
+    return this.trpc.events.getAudioSegments.query({ camera, after, before, providerId });
+  }
+  async getEventThumbnail(eventId, providerId) {
+    return this.trpc.events.getEventThumbnail.query({ eventId, providerId });
+  }
+  async getEventSnapshot(eventId, providerId) {
+    return this.trpc.events.getEventSnapshot.query({ eventId, providerId });
+  }
+  // ─── WebRTC ────────────────────────────────────────────────────
+  async webrtcOffer(streamName, sdpOffer, providerId) {
+    const result = await this.trpc.webrtc.offer.mutate({ streamName, sdpOffer, providerId });
+    return result.sdpAnswer;
+  }
+  // ─── HLS ───────────────────────────────────────────────────────
+  async getRecordingHls(camera, startTime, endTime, providerId) {
+    const result = await this.trpc.hls.getRecordingHls.query({
+      camera,
+      startTime,
+      endTime,
+      providerId
+    });
+    return `${this.baseUrl}${result.hlsUrl}`;
+  }
+  async getEventHls(eventId, providerId) {
+    const result = await this.trpc.hls.getEventHls.query({ eventId, providerId });
+    return `${this.baseUrl}${result.hlsUrl}`;
+  }
+  // ─── Live subscriptions ───────────────────────────────────────
+  subscribeLiveEvents(callback, options) {
+    const { onError, onStarted, onStopped, ...subOptions } = options ?? {};
+    return this.trpc.live.onEvent.subscribe(subOptions, {
+      onData: callback,
+      onError: onError ?? ((err) => console.error("[ProxyClient] subscription error:", err)),
+      onStarted: onStarted ?? (() => console.log("[ProxyClient] subscription started")),
+      onStopped: onStopped ?? (() => console.log("[ProxyClient] subscription stopped"))
+    });
+  }
+  subscribeMotion(camera, callback, providerId) {
+    return this.trpc.live.onMotion.subscribe(
+      { camera, providerId },
+      { onData: callback }
+    );
+  }
+  subscribeDetection(camera, callback, providerId) {
+    return this.trpc.live.onDetection.subscribe(
+      { camera, providerId },
+      { onData: callback }
+    );
+  }
+  subscribeAudioLevel(camera, callback, providerId) {
+    return this.trpc.live.onAudioLevel.subscribe(
+      { camera, providerId },
+      { onData: callback }
+    );
+  }
+};
+
+// src/direct-client.ts
+var DirectClient = class {
+  baseUrl;
+  type;
+  username;
+  password;
+  token = null;
+  constructor(config) {
+    this.baseUrl = config.directUrl.replace(/\/+$/, "");
+    this.type = config.type;
+    this.username = config.username;
+    this.password = config.password;
+  }
+  // ─── HTTP helpers ──────────────────────────────────────────────
+  authHeaders() {
+    if (this.token) return { Authorization: `Bearer ${this.token}` };
+    if (this.username && this.password) {
+      const basic = btoa(`${this.username}:${this.password}`);
+      return { Authorization: `Basic ${basic}` };
+    }
+    return {};
+  }
+  async request(path, init) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      ...this.authHeaders(),
+      ...init?.headers
+    };
+    const res = await fetch(url, { ...init, headers });
+    if (!res.ok) throw new Error(`NVR API ${res.status}: ${path}`);
+    return res;
+  }
+  // ─── Config ────────────────────────────────────────────────────
+  async getConfig() {
+    const res = await this.request("/api/config");
+    const raw = await res.json();
+    return { type: this.type, version: raw.version, raw };
+  }
+  async getStreams() {
+    if (this.type !== "frigate") return [];
+    for (const path of ["/api/go2rtc/streams", "/go2rtc/streams"]) {
+      try {
+        const res = await this.request(path);
+        const data = await res.json();
+        return Object.keys(data).map((name) => ({
+          name,
+          camera: name.split("_")[0]
+        }));
+      } catch {
+      }
+    }
+    return [];
+  }
+  // ─── Cameras ───────────────────────────────────────────────────
+  async listCameras() {
+    const config = await this.getConfig();
+    const raw = config.raw;
+    const cameras = raw?.cameras ?? {};
+    const streams = await this.getStreams();
+    const streamNames = streams.map((s) => s.name);
+    return Object.entries(cameras).map(([name, cam]) => {
+      const matching = streamNames.filter((s) => {
+        const sl = s.toLowerCase();
+        const cn = name.toLowerCase();
+        return sl === cn || sl.startsWith(`${cn}_`) || sl.startsWith(`${cn}.`);
+      });
+      return {
+        name,
+        label: name,
+        enabled: cam.enabled !== false,
+        hasAudio: cam.audio?.enabled === true,
+        hasPtz: !!cam.onvif?.host,
+        streams: matching,
+        streamOptions: []
+      };
+    });
+  }
+  async getSnapshot(camera) {
+    const res = await this.request(
+      `/api/${encodeURIComponent(camera)}/latest.jpg`
+    );
+    const blob = await res.blob();
+    const buffer = await blob.arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    for (const byte of bytes) binary += String.fromCharCode(byte);
+    return btoa(binary);
+  }
+  // ─── Events ────────────────────────────────────────────────────
+  async getEvents(params) {
+    const qs = new URLSearchParams();
+    if (params.after != null) qs.set("after", String(params.after));
+    if (params.before != null) qs.set("before", String(params.before));
+    if (params.cameras?.length) qs.set("cameras", params.cameras.join(","));
+    if (params.labels?.length) qs.set("labels", params.labels.join(","));
+    qs.set("limit", String(params.limit ?? 1e4));
+    const res = await this.request(`/api/events?${qs}`);
+    const raw = await res.json();
+    return raw.map((e) => ({
+      id: e.id,
+      camera: e.camera,
+      label: e.label,
+      startTime: e.start_time * 1e3,
+      endTime: e.end_time != null ? e.end_time * 1e3 : null,
+      severity: e.severity,
+      hasClip: e.has_clip === true,
+      hasSnapshot: e.has_snapshot === true,
+      thumbnailPath: `/api/events/${e.id}/thumbnail.jpg`,
+      snapshotPath: `/api/events/${e.id}/snapshot.jpg`,
+      clipPath: e.has_clip ? `/api/events/${e.id}/clip.mp4` : void 0
+    }));
+  }
+  async getRecordings(params) {
+    const qs = new URLSearchParams();
+    qs.set("after", String(params.after));
+    qs.set("before", String(params.before));
+    const res = await this.request(
+      `/api/${encodeURIComponent(params.camera)}/recordings?${qs}`
+    );
+    const data = await res.json();
+    const raw = Array.isArray(data) ? data : [];
+    return raw.map(
+      (r) => ({
+        id: r.id ?? `${params.camera}-${r.start_time}-${r.end_time}`,
+        camera: params.camera,
+        startTime: r.start_time * 1e3,
+        endTime: r.end_time * 1e3,
+        duration: r.duration * 1e3,
+        motion: r.motion,
+        objects: r.objects,
+        dBFS: r.dBFS
+      })
+    );
+  }
+  async getMotionActivity(params) {
+    const qs = new URLSearchParams();
+    qs.set("after", String(params.after));
+    qs.set("before", String(params.before));
+    if (params.scale != null) qs.set("scale", String(params.scale));
+    if (params.cameras?.length) qs.set("cameras", params.cameras.join(","));
+    const res = await this.request(`/api/review/activity/motion?${qs}`);
+    const data = await res.json();
+    const raw = Array.isArray(data) ? data : [];
+    return raw.map(
+      (m) => ({
+        camera: m.camera,
+        startTime: m.start_time * 1e3,
+        motion: m.motion,
+        audio: m.audio
+      })
+    );
+  }
+  /** Audio segments are not available in direct mode (tracked by proxy only). */
+  async getAudioSegments(_camera, _after, _before) {
+    return [];
+  }
+  async getEventThumbnail(eventId) {
+    const res = await this.request(
+      `/api/events/${encodeURIComponent(eventId)}/thumbnail.jpg`
+    );
+    const blob = await res.blob();
+    const buffer = await blob.arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    for (const byte of bytes) binary += String.fromCharCode(byte);
+    return btoa(binary);
+  }
+  async getEventSnapshot(eventId) {
+    const res = await this.request(
+      `/api/events/${encodeURIComponent(eventId)}/snapshot.jpg`
+    );
+    const blob = await res.blob();
+    const buffer = await blob.arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    for (const byte of bytes) binary += String.fromCharCode(byte);
+    return btoa(binary);
+  }
+  // ─── WebRTC (direct WHEP to go2rtc) ──────────────────────────
+  async webrtcOffer(streamName, sdpOffer) {
+    for (const basePath of ["/api/go2rtc/webrtc", "/go2rtc/api/webrtc"]) {
+      try {
+        const qs = new URLSearchParams({ src: streamName });
+        const res = await this.request(`${basePath}?${qs}`, {
+          method: "POST",
+          headers: { "Content-Type": "application/sdp" },
+          body: sdpOffer
+        });
+        return await res.text();
+      } catch {
+      }
+    }
+    throw new Error(`WebRTC SDP failed for stream: ${streamName}`);
+  }
+  // ─── HLS (direct to Frigate VOD) ─────────────────────────────
+  getRecordingHlsUrl(camera, startTime, endTime) {
+    const start = Math.floor(startTime);
+    const end = Math.ceil(endTime);
+    return `${this.baseUrl}/vod/${encodeURIComponent(camera)}/start/${start}/end/${end}/master.m3u8`;
+  }
+  getEventHlsUrl(eventId) {
+    return `${this.baseUrl}/vod/event/${encodeURIComponent(eventId)}/master.m3u8`;
+  }
+};
+
+// src/types.ts
+function isProxyConfig(config) {
+  return "proxyUrl" in config;
+}
+
+// src/client.ts
+var CamStackClient = class {
+  proxy = null;
+  direct = null;
+  isProxy;
+  constructor(config) {
+    if (isProxyConfig(config)) {
+      this.proxy = new ProxyClient(config);
+      this.isProxy = true;
+    } else {
+      this.direct = new DirectClient(config);
+      this.isProxy = false;
+    }
+  }
+  // ─── Providers ───────────────────────────────────────────────────
+  async listProviders() {
+    if (!this.proxy) return [];
+    return this.proxy.listProviders();
+  }
+  // ─── Config ────────────────────────────────────────────────────
+  async getConfig(providerId) {
+    if (this.proxy) return this.proxy.getConfig(providerId);
+    return this.direct.getConfig();
+  }
+  async getStreams(providerId) {
+    if (this.proxy) return this.proxy.getStreams(providerId);
+    return this.direct.getStreams();
+  }
+  // ─── Cameras ───────────────────────────────────────────────────
+  async listCameras(providerId) {
+    if (this.proxy) return this.proxy.listCameras(providerId);
+    return this.direct.listCameras();
+  }
+  async getSnapshot(camera, providerId) {
+    if (this.proxy) return this.proxy.getSnapshot(camera, providerId);
+    return this.direct.getSnapshot(camera);
+  }
+  // ─── Events ────────────────────────────────────────────────────
+  async getEvents(params) {
+    if (this.proxy) return this.proxy.getEvents(params);
+    return this.direct.getEvents(params);
+  }
+  async getRecordings(params) {
+    if (this.proxy) return this.proxy.getRecordings(params);
+    return this.direct.getRecordings(params);
+  }
+  async getMotionActivity(params) {
+    if (this.proxy) return this.proxy.getMotionActivity(params);
+    return this.direct.getMotionActivity(params);
+  }
+  async getAudioSegments(camera, after, before, providerId) {
+    if (this.proxy) return this.proxy.getAudioSegments(camera, after, before, providerId);
+    return this.direct.getAudioSegments(camera, after, before);
+  }
+  async getEventThumbnail(eventId, providerId) {
+    if (this.proxy) return this.proxy.getEventThumbnail(eventId, providerId);
+    return this.direct.getEventThumbnail(eventId);
+  }
+  async getEventSnapshot(eventId, providerId) {
+    if (this.proxy) return this.proxy.getEventSnapshot(eventId, providerId);
+    return this.direct.getEventSnapshot(eventId);
+  }
+  // ─── WebRTC ────────────────────────────────────────────────────
+  async webrtcOffer(streamName, sdpOffer, providerId) {
+    if (this.proxy) return this.proxy.webrtcOffer(streamName, sdpOffer, providerId);
+    return this.direct.webrtcOffer(streamName, sdpOffer);
+  }
+  // ─── HLS ───────────────────────────────────────────────────────
+  async getRecordingHlsUrl(camera, startTime, endTime, providerId) {
+    if (this.proxy) {
+      return this.proxy.getRecordingHls(camera, startTime, endTime, providerId);
+    }
+    return this.direct.getRecordingHlsUrl(camera, startTime, endTime);
+  }
+  async getEventHlsUrl(eventId, providerId) {
+    if (this.proxy) {
+      return this.proxy.getEventHls(eventId, providerId);
+    }
+    return this.direct.getEventHlsUrl(eventId);
+  }
+  // ─── Live subscriptions (proxy mode only) ─────────────────────
+  subscribeLiveEvents(callback, options) {
+    if (!this.proxy) {
+      throw new Error("Live subscriptions require proxy mode.");
+    }
+    return this.proxy.subscribeLiveEvents(callback, options);
+  }
+  subscribeMotion(camera, callback, providerId) {
+    if (!this.proxy) throw new Error("Live subscriptions require proxy mode.");
+    return this.proxy.subscribeMotion(camera, callback, providerId);
+  }
+  subscribeDetection(camera, callback, providerId) {
+    if (!this.proxy) throw new Error("Live subscriptions require proxy mode.");
+    return this.proxy.subscribeDetection(camera, callback, providerId);
+  }
+  subscribeAudioLevel(camera, callback, providerId) {
+    if (!this.proxy) throw new Error("Live subscriptions require proxy mode.");
+    return this.proxy.subscribeAudioLevel(camera, callback, providerId);
+  }
+};
+function createCamStackClient(config) {
+  return new CamStackClient(config);
+}
+
+// src/detection.ts
+var DetectionClass = /* @__PURE__ */ ((DetectionClass2) => {
+  DetectionClass2["Motion"] = "motion";
+  DetectionClass2["Person"] = "person";
+  DetectionClass2["Vehicle"] = "vehicle";
+  DetectionClass2["Animal"] = "animal";
+  DetectionClass2["Audio"] = "audio";
+  DetectionClass2["Face"] = "face";
+  DetectionClass2["Plate"] = "plate";
+  DetectionClass2["Package"] = "package";
+  DetectionClass2["Doorbell"] = "doorbell";
+  DetectionClass2["Sensor"] = "sensor";
+  return DetectionClass2;
+})(DetectionClass || {});
+var animalClasses = [
+  "animal" /* Animal */,
+  "dog_cat",
+  "dog",
+  "cat",
+  "horse",
+  "sheep",
+  "cow",
+  "elephant",
+  "bear",
+  "zebra",
+  "giraffe",
+  "mouse",
+  "rabbit",
+  "deer",
+  "lion",
+  "tiger",
+  "bird",
+  "eagle",
+  "owl",
+  "pigeon",
+  "fish",
+  "whale",
+  "dolphin",
+  "snake",
+  "turtle",
+  "lizard"
+];
+var personClasses = [
+  "person" /* Person */,
+  "people",
+  "pedestrian",
+  "rider",
+  "driver",
+  "cyclist",
+  "skier",
+  "skateboarder",
+  "face",
+  "hand",
+  "head",
+  "body"
+];
+var vehicleClasses = [
+  "vehicle" /* Vehicle */,
+  "car",
+  "truck",
+  "bus",
+  "motorcycle",
+  "bicycle",
+  "van",
+  "ambulance",
+  "police_car",
+  "fire_truck",
+  "train",
+  "subway",
+  "tram",
+  "airplane",
+  "boat",
+  "ship",
+  "helicopter"
+];
+var faceClasses = [
+  "face" /* Face */,
+  "eyes",
+  "nose",
+  "mouth",
+  "ears",
+  "eyebrows",
+  "left_eye",
+  "right_eye",
+  "pupil",
+  "iris",
+  "eyelid",
+  "eye_corner",
+  "upper_lip",
+  "lower_lip",
+  "teeth",
+  "chin",
+  "cheek",
+  "forehead",
+  "jaw",
+  "glasses",
+  "sunglasses",
+  "facial_hair",
+  "beard",
+  "mustache",
+  "facial_landmark",
+  "facial_keypoint"
+];
+var licensePlateClasses = [
+  "plate" /* Plate */,
+  "license_plate",
+  "front_plate",
+  "rear_plate",
+  "motorcycle_plate",
+  "temporary_plate",
+  "dealer_plate",
+  "licensePlate",
+  "plate_number",
+  "plate_character",
+  "plate_digit",
+  "plate_letter",
+  "plate_symbol",
+  "plate_region",
+  "plate_country_identifier",
+  "plate_frame",
+  "plate_bolt",
+  "plate_sticker",
+  "plate_validation_tag",
+  "damaged_plate",
+  "obscured_plate",
+  "dirty_plate"
+];
+var motionClasses = ["motion" /* Motion */, "movement", "other"];
+var packageClasses = ["package" /* Package */, "packet"];
+var audioClasses = ["audio" /* Audio */];
+var audioLabelClasses = [
+  "speech",
+  "scream",
+  "babbling",
+  "yell",
+  "bellow",
+  "whoop",
+  "whispering",
+  "laughter",
+  "snicker",
+  "crying",
+  "cry",
+  "sigh",
+  "singing",
+  "choir",
+  "chant",
+  "mantra",
+  "child_singing",
+  "rapping",
+  "humming",
+  "groan",
+  "grunt",
+  "whistling",
+  "breathing",
+  "wheeze",
+  "snoring",
+  "gasp",
+  "pant",
+  "snort",
+  "cough",
+  "throat_clearing",
+  "sneeze",
+  "sniff",
+  "cheering",
+  "applause",
+  "chatter",
+  "crowd",
+  "children_playing",
+  "bark",
+  "yip",
+  "howl",
+  "bow-wow",
+  "growling",
+  "whimper_dog",
+  "purr",
+  "meow",
+  "hiss",
+  "caterwaul",
+  "pets",
+  "livestock",
+  "doorbell",
+  "ding-dong",
+  "door",
+  "slam",
+  "knock",
+  "alarm",
+  "telephone",
+  "music",
+  "dog",
+  "dogs"
+];
+var doorbellClasses = ["doorbell" /* Doorbell */, "ring"];
+var sensorLabelClasses = [
+  "lock",
+  "binary",
+  "flood",
+  "entry",
+  "door",
+  "leak",
+  "door_open",
+  "flooded",
+  "entry_open"
+];
+var detectionClassesDefaultMap = {
+  ...animalClasses.reduce((tot, curr) => ({ ...tot, [curr]: "animal" /* Animal */ }), {}),
+  ...personClasses.reduce((tot, curr) => ({ ...tot, [curr]: "person" /* Person */ }), {}),
+  ...vehicleClasses.reduce((tot, curr) => ({ ...tot, [curr]: "vehicle" /* Vehicle */ }), {}),
+  ...motionClasses.reduce((tot, curr) => ({ ...tot, [curr]: "motion" /* Motion */ }), {}),
+  ...packageClasses.reduce((tot, curr) => ({ ...tot, [curr]: "package" /* Package */ }), {}),
+  ...faceClasses.reduce((tot, curr) => ({ ...tot, [curr]: "face" /* Face */ }), {}),
+  ...licensePlateClasses.reduce((tot, curr) => ({ ...tot, [curr]: "plate" /* Plate */ }), {}),
+  ...audioClasses.reduce((tot, curr) => ({ ...tot, [curr]: "audio" /* Audio */ }), {}),
+  ...audioLabelClasses.reduce((tot, curr) => ({ ...tot, [curr]: "audio" /* Audio */ }), {}),
+  ...doorbellClasses.reduce((tot, curr) => ({ ...tot, [curr]: "doorbell" /* Doorbell */ }), {}),
+  ...sensorLabelClasses.reduce((tot, curr) => ({ ...tot, [curr]: "sensor" /* Sensor */ }), {})
+};
+var isFaceClassname = (c) => faceClasses.includes(c);
+var isPlateClassname = (c) => licensePlateClasses.includes(c);
+var isAnimalClassname = (c) => animalClasses.includes(c);
+var isPersonClassname = (c) => personClasses.includes(c);
+var isVehicleClassname = (c) => vehicleClasses.includes(c);
+var isMotionClassname = (c) => motionClasses.includes(c);
+var isDoorbellClassname = (c) => doorbellClasses.includes(c);
+var isPackageClassname = (c) => packageClasses.includes(c);
+var isAudioClassname = (c) => audioClasses.includes(c) || audioLabelClasses.includes(c);
+var isSensorLabelClassname = (c) => sensorLabelClasses.includes(c);
+var isLabelDetection = (c) => isFaceClassname(c) || isPlateClassname(c);
+var getParentClass = (className) => detectionClassesDefaultMap[className];
+var getParentDetectionClass = (det) => {
+  const { className } = det;
+  const baseMap = {
+    ["face" /* Face */]: "person" /* Person */,
+    ["plate" /* Plate */]: "vehicle" /* Vehicle */
+  };
+  const parentGroup = detectionClassesDefaultMap[className];
+  if (parentGroup && parentGroup !== className) return parentGroup;
+  return baseMap[className];
+};
+var defaultDetectionClasses = Object.values(DetectionClass);
+var DEFAULT_ENABLED_CLASSES = defaultDetectionClasses.filter(
+  (c) => c !== "motion" /* Motion */
+);
+var TIMELINE_PRESET_CRITICAL = [
+  "person" /* Person */,
+  "doorbell" /* Doorbell */,
+  "package" /* Package */
+];
+var TIMELINE_PRESET_IMPORTANT = [
+  ...TIMELINE_PRESET_CRITICAL,
+  "vehicle" /* Vehicle */,
+  "animal" /* Animal */,
+  "audio" /* Audio */,
+  "face" /* Face */,
+  "plate" /* Plate */
+];
+var TIMELINE_PRESET_ALL = [...DEFAULT_ENABLED_CLASSES];
+function getClassesForTimelinePreset(preset, customClasses) {
+  switch (preset) {
+    case "critical":
+      return TIMELINE_PRESET_CRITICAL;
+    case "important":
+      return TIMELINE_PRESET_IMPORTANT;
+    case "all":
+      return TIMELINE_PRESET_ALL;
+    case "custom":
+      return customClasses?.length ? customClasses : DEFAULT_ENABLED_CLASSES;
+    default:
+      return DEFAULT_ENABLED_CLASSES;
+  }
+}
+
+// src/devices.ts
+var RAW_TO_CANONICAL = {
+  // Scrypted PascalCase
+  Light: "light",
+  Switch: "switch",
+  WindowCovering: "cover",
+  Lock: "lock",
+  SecuritySystem: "alarm",
+  Buttons: "button",
+  Select: "select",
+  Siren: "siren",
+  Sensor: "sensor",
+  Entry: "entry",
+  Program: "script",
+  MediaPlayer: "media_player",
+  Outlet: "switch",
+  // Home Assistant lowercase domains
+  light: "light",
+  switch: "switch",
+  input_boolean: "switch",
+  cover: "cover",
+  lock: "lock",
+  alarm_control_panel: "alarm",
+  input_button: "button",
+  button: "button",
+  input_select: "select",
+  select: "select",
+  siren: "siren",
+  sensor: "sensor",
+  media_player: "media_player",
+  script: "script"
+};
+var HA_DOMAIN_TYPE_MAP = {
+  light: "light",
+  switch: "switch",
+  input_boolean: "switch",
+  cover: "cover",
+  lock: "lock",
+  alarm_control_panel: "alarm",
+  input_button: "button",
+  button: "button",
+  input_select: "select",
+  select: "select",
+  siren: "siren",
+  sensor: "sensor",
+  binary_sensor: "sensor",
+  media_player: "media_player",
+  script: "script",
+  climate: "climate",
+  camera: "camera",
+  fan: "fan",
+  vacuum: "vacuum",
+  automation: "automation",
+  scene: "scene",
+  input_number: "sensor",
+  person: "person",
+  device_tracker: "tracker",
+  weather: "weather",
+  water_heater: "climate"
+};
+var SCRYPTED_TYPE_TO_CANONICAL = {
+  Light: "light",
+  Switch: "switch",
+  WindowCovering: "cover",
+  Lock: "lock",
+  SecuritySystem: "alarm",
+  Buttons: "button",
+  Select: "select",
+  Siren: "siren",
+  Sensor: "sensor",
+  Entry: "entry",
+  Program: "script",
+  MediaPlayer: "media_player",
+  Camera: "camera",
+  Doorbell: "doorbell",
+  Fan: "fan",
+  Outlet: "switch"
+};
+function getCanonicalDeviceType(rawType) {
+  const canonical = RAW_TO_CANONICAL[rawType];
+  if (canonical) return canonical;
+  const lower = rawType.toLowerCase();
+  return RAW_TO_CANONICAL[lower] ?? null;
+}
+var ELIGIBLE_SCRYPTED_DEVICE_TYPES = [
+  "Entry",
+  "Light",
+  "Switch",
+  "Lock",
+  "SecuritySystem",
+  "Buttons",
+  "WindowCovering",
+  "Siren",
+  "Sensor",
+  "Select",
+  "Program"
+];
+var ELIGIBLE_SCRYPTED_DEVICE_TYPES_SET = new Set(ELIGIBLE_SCRYPTED_DEVICE_TYPES);
+var ELIGIBLE_HA_DOMAINS = [
+  "light",
+  "switch",
+  "input_boolean",
+  "cover",
+  "lock",
+  "alarm_control_panel",
+  "input_button",
+  "button",
+  "input_select",
+  "select",
+  "siren",
+  "media_player",
+  "script"
+];
+var ELIGIBLE_HA_DOMAINS_SET = new Set(ELIGIBLE_HA_DOMAINS);
+
+// src/features.ts
+var FEATURE_MATRIX = [
+  {
+    id: "liveStream",
+    label: "Live Stream",
+    sources: { frigate: true, scrypted: true, rtsp: true },
+    adapterMethod: "getLiveStream"
+  },
+  {
+    id: "multiResolution",
+    label: "Multi-Resolution",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getResolutions"
+  },
+  {
+    id: "motion",
+    label: "Motion Detection",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getMotion"
+  },
+  {
+    id: "objectDetection",
+    label: "Object Detection",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getObjectDetections"
+  },
+  {
+    id: "audioVolume",
+    label: "Audio Level",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getAudioVolume"
+  },
+  {
+    id: "audioVolumes",
+    label: "Audio Volumes (dBFS)",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getAudioVolumes"
+  },
+  {
+    id: "ptz",
+    label: "PTZ Control",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getPTZ"
+  },
+  {
+    id: "intercom",
+    label: "Intercom (Mic)",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getIntercomSupport"
+  },
+  {
+    id: "deviceStatus",
+    label: "Device Status",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getStatus"
+  },
+  {
+    id: "timeline",
+    label: "Detection Timeline",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getCameraDayData"
+  },
+  {
+    id: "clusteredTimeline",
+    label: "Clustered Timeline",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    requiresBackend: true,
+    adapterMethod: "getClusteredDayData"
+  },
+  {
+    id: "detectionClasses",
+    label: "Detection Classes",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getDetectionClasses"
+  },
+  {
+    id: "videoClips",
+    label: "Video Clips",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getVideoClips"
+  },
+  {
+    id: "nvrPlayback",
+    label: "NVR Playback",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getNvrPlaybackSupported"
+  },
+  {
+    id: "nvrScrub",
+    label: "NVR Scrub/Seek",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "seekRecordingStream"
+  },
+  {
+    id: "recordingThumbnail",
+    label: "Recording Thumbnails",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getRecordingStreamThumbnail"
+  },
+  {
+    id: "nvrSeekToLive",
+    label: "Seek to Live",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "seekNvrToLive"
+  }
+];
+function isFeatureAvailable(featureId, source, platform) {
+  const entry = FEATURE_MATRIX.find((f) => f.id === featureId);
+  if (!entry) return false;
+  if (!entry.sources[source]) return false;
+  if (entry.platforms && entry.platforms[platform] === false) return false;
+  return true;
+}
+function getSourceFeatures(source) {
+  return FEATURE_MATRIX.filter((f) => f.sources[source]);
+}
+function getBackendRequiredFeatures() {
+  return FEATURE_MATRIX.filter((f) => f.requiresBackend);
+}
+export {
+  CamStackClient,
+  DEFAULT_ENABLED_CLASSES,
+  DetectionClass,
+  DirectClient,
+  ELIGIBLE_HA_DOMAINS,
+  ELIGIBLE_HA_DOMAINS_SET,
+  ELIGIBLE_SCRYPTED_DEVICE_TYPES,
+  ELIGIBLE_SCRYPTED_DEVICE_TYPES_SET,
+  FEATURE_MATRIX,
+  HA_DOMAIN_TYPE_MAP,
+  ProxyClient,
+  RAW_TO_CANONICAL,
+  SCRYPTED_TYPE_TO_CANONICAL,
+  TIMELINE_PRESET_ALL,
+  TIMELINE_PRESET_CRITICAL,
+  TIMELINE_PRESET_IMPORTANT,
+  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
+};
+//# sourceMappingURL=index.js.map