@busy-app/busy-lib 0.11.0 → 0.13.0

package/dist/index.js

@@ -1,112 +1,113 @@
-var G = Object.defineProperty;
-var P = (n, t, i) => t in n ? G(n, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : n[t] = i;
-var c = (n, t, i) => P(n, typeof t != "symbol" ? t + "" : t, i);
-import m from "openapi-fetch";
-const L = (n, t) => {
-  if (typeof FormData < "u" && n instanceof FormData || typeof Buffer < "u" && typeof Buffer.isBuffer == "function" && Buffer.isBuffer(n) || typeof File < "u" && n instanceof File || typeof Blob < "u" && n instanceof Blob || typeof ArrayBuffer < "u" && n instanceof ArrayBuffer || typeof ArrayBuffer < "u" && ArrayBuffer.isView && ArrayBuffer.isView(n))
-    return n;
-  let i;
-  return t && (t instanceof Headers ? i = t.get("Content-Type") ?? t.get("content-type") ?? void 0 : typeof t == "object" && (i = t["Content-Type"] ?? t["content-type"]), i === "application/x-www-form-urlencoded") ? n && typeof n == "object" && !(n instanceof URLSearchParams) ? new URLSearchParams(n).toString() : String(n) : JSON.stringify(n);
+var B = Object.defineProperty;
+var F = (r, t, e) => t in r ? B(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var u = (r, t, e) => F(r, typeof t != "symbol" ? t + "" : t, e);
+import O from "openapi-fetch";
+import { W as S, D as C, A as k, C as E, S as f, a as y, b as d } from "./types.status-gCPe7MrJ.js";
+const W = (r, t) => {
+  if (typeof FormData < "u" && r instanceof FormData || typeof Buffer < "u" && typeof Buffer.isBuffer == "function" && Buffer.isBuffer(r) || typeof File < "u" && r instanceof File || typeof Blob < "u" && r instanceof Blob || typeof ArrayBuffer < "u" && r instanceof ArrayBuffer || typeof ArrayBuffer < "u" && ArrayBuffer.isView && ArrayBuffer.isView(r))
+    return r;
+  let e;
+  return t && (t instanceof Headers ? e = t.get("Content-Type") ?? t.get("content-type") ?? void 0 : typeof t == "object" && (e = t["Content-Type"] ?? t["content-type"]), e === "application/x-www-form-urlencoded") ? r && typeof r == "object" && !(r instanceof URLSearchParams) ? new URLSearchParams(r).toString() : String(r) : JSON.stringify(r);
 };
-async function y(n) {
-  const e = (n.headers.get("content-type") || "").includes("application/json") ? await n.clone().json() : await n.clone().text(), r = typeof e == "object" && e !== null ? e.error || e.message : typeof e == "string" ? e : void 0;
-  return Object.assign(new Error(r || `HTTP ${n.status} ${n.statusText}`), {
-    status: n.status,
-    statusText: n.statusText,
-    body: e
+async function b(r) {
+  const i = (r.headers.get("content-type") || "").includes("application/json") ? await r.clone().json() : await r.clone().text(), n = typeof i == "object" && i !== null ? i.error || i.message : typeof i == "string" ? i : void 0;
+  return Object.assign(new Error(n || `HTTP ${r.status} ${r.statusText}`), {
+    status: r.status,
+    statusText: r.statusText,
+    body: i
   });
 }
-async function s(n, t = 3e3) {
+async function a(r, t = 3e3) {
   if (t <= 0)
-    return await n();
-  const i = new AbortController(), e = setTimeout(() => i.abort(), t);
+    return await r();
+  const e = new AbortController(), i = setTimeout(() => e.abort(), t);
   try {
-    return await n(i.signal);
-  } catch (r) {
-    throw r instanceof DOMException && r.name === "AbortError" ? new Error(`Request timed out after ${t}ms`) : r;
+    return await r(e.signal);
+  } catch (n) {
+    throw n instanceof DOMException && n.name === "AbortError" ? new Error(`Request timed out after ${t}ms`) : n;
   } finally {
-    clearTimeout(e);
+    clearTimeout(i);
   }
 }
-function O(n, t, i) {
-  let e, r = i ?? void 0, o, a = null;
-  const u = async () => {
-    e || (a || (a = (async () => {
-      const h = await t();
-      if (!h.api_semver)
+function M(r, t, e) {
+  let i, n = e ?? void 0, s, o = null;
+  const h = async () => {
+    i || (o || (o = (async () => {
+      const l = await t();
+      if (!l.api_semver)
         throw new Error("Empty API version");
-      e = h.api_semver;
+      i = l.api_semver;
     })().finally(() => {
-      a = null;
-    })), await a);
-  }, w = {
-    async onRequest({ request: h, schemaPath: d }) {
-      return r && h.headers.set("Authorization", `Bearer ${r}`), d !== "/version" && (await u(), e && h.headers.set("X-API-Sem-Ver", e), o && h.headers.set("X-API-Token", o)), h;
+      o = null;
+    })), await o);
+  }, c = {
+    async onRequest({ request: l, schemaPath: w }) {
+      return n && l.headers.set("Authorization", `Bearer ${n}`), w !== "/version" && (await h(), i && l.headers.set("X-API-Sem-Ver", i), s && l.headers.set("X-API-Token", s)), l;
     },
-    async onResponse({ request: h, response: d, options: b, schemaPath: v }) {
-      if (d.ok)
-        return d;
-      if (v === "/version")
-        throw await y(d);
-      if (d.status !== 405)
-        throw await y(d);
-      e = void 0, await u(), e && h.headers.set("X-API-Sem-Ver", e), r && h.headers.set("Authorization", `Bearer ${r}`);
-      const l = await (b.fetch ?? fetch)(h);
-      if (l.ok)
-        return l;
-      throw await y(l);
+    async onResponse({ request: l, response: w, options: G, schemaPath: x }) {
+      if (w.ok)
+        return w;
+      if (x === "/version")
+        throw await b(w);
+      if (w.status !== 405)
+        throw await b(w);
+      i = void 0, await h(), i && l.headers.set("X-API-Sem-Ver", i), n && l.headers.set("Authorization", `Bearer ${n}`);
+      const A = await (G.fetch ?? fetch)(l);
+      if (A.ok)
+        return A;
+      throw await b(A);
     }
-  }, f = m({
-    baseUrl: n,
-    bodySerializer: L
+  }, p = O({
+    baseUrl: r,
+    bodySerializer: W
   });
-  return f.use(w), {
-    client: f,
-    setApiKey: (h) => {
-      o = h;
+  return p.use(c), {
+    client: p,
+    setApiKey: (l) => {
+      s = l;
     },
-    setToken: (h) => {
-      r = h;
+    setToken: (l) => {
+      n = l;
     }
   };
 }
-async function D(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/version", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function $(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/version", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function U(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/status", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function K(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/status", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function B(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/status/system", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function z(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/status/system", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function I(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/status/power", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function H(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/status/power", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function $(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/status/device", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function q(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/status/device", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function R(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/status/firmware", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function V(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/status/firmware", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-class K {
+class X {
   /**
    * Get API version information.
    *
@@ -115,8 +116,8 @@ class K {
    * @returns {Promise<VersionInfo>} A promise that resolves to an object containing the `api_semver` string.
    */
   async SystemVersionGet(t) {
-    const i = await D(this.apiClient, t);
-    return this.apiSemver = i.api_semver, i;
+    const e = await $(this.apiClient, t);
+    return this.apiSemver = e.api_semver, e;
   }
   /**
    * Get full status.
@@ -126,7 +127,7 @@ class K {
    * @returns {Promise<Status>} Current status of the device.
    */
   async SystemStatusGet(t) {
-    return await U(this.apiClient, t);
+    return await K(this.apiClient, t);
   }
   /**
    * Get system status.
@@ -136,7 +137,7 @@ class K {
    * @returns {Promise<StatusSystem>} Current system status.
    */
   async SystemInfoGet(t) {
-    return await B(this.apiClient, t);
+    return await z(this.apiClient, t);
   }
   /**
    * Get power status.
@@ -146,7 +147,7 @@ class K {
    * @returns {Promise<StatusPower>} Current power status.
    */
   async SystemStatusPowerGet(t) {
-    return await I(this.apiClient, t);
+    return await H(this.apiClient, t);
   }
   /**
    * Get device status.
@@ -156,7 +157,7 @@ class K {
    * @returns {Promise<StatusDevice>} Current device status.
    */
   async SystemStatusDeviceGet(t) {
-    return await $(this.apiClient, t);
+    return await q(this.apiClient, t);
   }
   /**
    * Get firmware status.
@@ -166,93 +167,93 @@ class K {
    * @returns {Promise<StatusFirmware>} Current firmware status.
    */
   async SystemStatusFirmwareGet(t) {
-    return await R(this.apiClient, t);
+    return await V(this.apiClient, t);
   }
 }
-async function F(n, t) {
-  const { file: i } = t, { data: e, error: r } = await s(
-    (o) => n.POST("/update", {
+async function j(r, t) {
+  const { file: e } = t, { data: i, error: n } = await a(
+    (s) => r.POST("/update", {
       headers: {
         "Content-Type": "application/octet-stream"
       },
-      body: i,
-      signal: o
+      body: e,
+      signal: s
     }),
     t.timeout
   );
-  if (r)
-    throw r;
-  return e;
-}
-async function _(n, t) {
-  const { data: i, error: e } = await s((r) => n.POST("/update/check", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
+  if (n)
+    throw n;
   return i;
 }
-async function W(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/update/status", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function Y(r, t) {
+  const { data: e, error: i } = await a((n) => r.POST("/update/check", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function M(n, t) {
-  const { version: i } = t, { data: e, error: r } = await s(
-    (o) => n.GET("/update/changelog", {
+async function J(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/update/status", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
+}
+async function Q(r, t) {
+  const { version: e } = t, { data: i, error: n } = await a(
+    (s) => r.GET("/update/changelog", {
       params: {
         query: {
-          version: i
+          version: e
         }
       },
-      signal: o
+      signal: s
     }),
     t.timeout
   );
-  if (r)
-    throw r;
-  return e;
+  if (n)
+    throw n;
+  return i;
 }
-async function N(n, t) {
-  const { version: i } = t, { data: e, error: r } = await s(
-    (o) => n.POST("/update/install", {
+async function Z(r, t) {
+  const { version: e } = t, { data: i, error: n } = await a(
+    (s) => r.POST("/update/install", {
       params: {
         query: {
-          version: i
+          version: e
         }
       },
-      signal: o
+      signal: s
     }),
     t.timeout
   );
-  if (r)
-    throw r;
-  return e;
-}
-async function q(n, t) {
-  const { data: i, error: e } = await s((r) => n.POST("/update/abort_download", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
+  if (n)
+    throw n;
   return i;
 }
-async function x(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/update/autoupdate", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function tt(r, t) {
+  const { data: e, error: i } = await a((n) => r.POST("/update/abort_download", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
+}
+async function et(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/update/autoupdate", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function V(n, t) {
-  const { is_enabled: i, interval_start: e, interval_end: r } = t, { data: o, error: a } = await s(
-    (u) => n.POST("/update/autoupdate", {
-      body: { is_enabled: i, interval_start: e, interval_end: r },
-      signal: u
+async function it(r, t) {
+  const { is_enabled: e, interval_start: i, interval_end: n } = t, { data: s, error: o } = await a(
+    (h) => r.POST("/update/autoupdate", {
+      body: { is_enabled: e, interval_start: i, interval_end: n },
+      signal: h
     }),
     t.timeout
   );
-  if (a)
-    throw a;
-  return o;
+  if (o)
+    throw o;
+  return s;
 }
-class j {
+class rt {
   /**
    * Upload firmware update package.
    *
@@ -262,7 +263,7 @@ class j {
    * @returns {Promise<SuccessResponse>} A promise that resolves when upload is complete.
    */
   async UpdateFromFile(t) {
-    return await F(this.apiClient, t);
+    return await j(this.apiClient, t);
   }
   /**
    * Start firmware update check.
@@ -272,7 +273,7 @@ class j {
    * @returns {Promise<SuccessResponse>} A promise that resolves to the update check result.
    */
   async UpdateCheck(t) {
-    return await _(this.apiClient, t);
+    return await Y(this.apiClient, t);
   }
   /**
    * Get firmware update status.
@@ -282,7 +283,7 @@ class j {
    * @returns {Promise<UpdateStatus>} A promise that resolves to the update status.
    */
   async UpdateStatusGet(t) {
-    return await W(this.apiClient, t);
+    return await J(this.apiClient, t);
   }
   /**
    * Get firmware update changelog.
@@ -293,7 +294,7 @@ class j {
    * @returns {Promise<UpdateChangelog>} A promise that resolves to the changelog content.
    */
   async UpdateChangelogGet(t) {
-    return await M(this.apiClient, t);
+    return await Q(this.apiClient, t);
   }
   /**
    * Start firmware update installation.
@@ -304,7 +305,7 @@ class j {
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful initiation.
    */
   async UpdateInstall(t) {
-    return await N(this.apiClient, t);
+    return await Z(this.apiClient, t);
   }
   /**
    * Abort firmware update download.
@@ -314,7 +315,7 @@ class j {
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful abort.
    */
   async UpdateAbort(t) {
-    return await q(this.apiClient, t);
+    return await tt(this.apiClient, t);
   }
   /**
    * Get current auto-update settings.
@@ -324,7 +325,7 @@ class j {
    * @returns {Promise<AutoUpdateSettings>} A promise that resolves to the current auto-update settings.
    */
   async UpdateAutoUpdateGet(t) {
-    return await x(this.apiClient, t);
+    return await et(this.apiClient, t);
   }
   /**
    * Set auto-update settings.
@@ -337,56 +338,56 @@ class j {
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful update of settings.
    */
   async UpdateAutoUpdateSet(t) {
-    return await V(this.apiClient, t);
+    return await it(this.apiClient, t);
   }
 }
-async function z(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/time", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function nt(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/time", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function H(n, t) {
-  const { data: i, error: e } = await s(
-    (r) => n.POST("/time/timestamp", {
+async function st(r, t) {
+  const { timestamp: e } = t, { data: i, error: n } = await a(
+    (s) => r.POST("/time/timestamp", {
       params: {
-        query: { ...t, timeout: void 0 }
+        query: { timestamp: e }
       },
-      signal: r
+      signal: s
     }),
     t.timeout
   );
-  if (e)
-    throw e;
+  if (n)
+    throw n;
   return i;
 }
-async function J(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/time/timezone", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function at(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/time/timezone", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function X(n, t) {
-  const { data: i, error: e } = await s(
-    (r) => n.POST("/time/timezone", {
+async function ot(r, t) {
+  const { timezone: e } = t, { data: i, error: n } = await a(
+    (s) => r.POST("/time/timezone", {
       params: {
-        query: { ...t, timeout: void 0 }
+        query: { timezone: e }
       },
-      signal: r
+      signal: s
     }),
     t.timeout
   );
-  if (e)
-    throw e;
+  if (n)
+    throw n;
   return i;
 }
-async function Y(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/time/tzlist", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function ct(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/time/tzlist", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-class Q {
+class ut {
   /**
    * Get current timestamp info.
    *
@@ -395,7 +396,7 @@ class Q {
    * @returns {Promise<TimestampInfo>} A promise that resolves to the timestamp information.
    */
   async TimeGet(t) {
-    return await z(this.apiClient, t);
+    return await nt(this.apiClient, t);
   }
   /**
    * Set system timestamp.
@@ -406,7 +407,7 @@ class Q {
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
   async TimeTimestampSet(t) {
-    return await H(this.apiClient, t);
+    return await st(this.apiClient, t);
   }
   /**
    * Get current timezone.
@@ -416,7 +417,7 @@ class Q {
    * @returns {Promise<TimezoneInfo>} A promise that resolves to the timezone information.
    */
   async TimeTimezoneGet(t) {
-    return await J(this.apiClient, t);
+    return await at(this.apiClient, t);
   }
   /**
    * Set system timezone.
@@ -427,7 +428,7 @@ class Q {
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
   async TimeTimezoneSet(t) {
-    return await X(this.apiClient, t);
+    return await ot(this.apiClient, t);
   }
   /**
    * Get list of supported timezones.
@@ -437,56 +438,57 @@ class Q {
    * @returns {Promise<TimezoneList>} A promise that resolves to a list of timezone items.
    */
   async TimeTzListGet(t) {
-    return await Y(this.apiClient, t);
+    return await ct(this.apiClient, t);
   }
 }
-async function Z(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/account/status", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function ht(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/account/status", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function tt(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/account/info", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function lt(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/account/info", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function et(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/account/profile", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function dt(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/account/profile", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function it(n, t) {
-  const { profile: i } = t, { data: e, error: r } = await s(
-    (o) => n.POST("/account/profile", {
+async function ft(r, t) {
+  const { profile: e, custom_url: i } = t, { data: n, error: s } = await a(
+    (o) => r.POST("/account/profile", {
       params: {
         query: {
-          profile: i
+          profile: e,
+          custom_url: i
         }
       },
       signal: o
     }),
     t.timeout
   );
-  if (r)
-    throw r;
+  if (s)
+    throw s;
+  return n;
+}
+async function wt(r, t) {
+  const { data: e, error: i } = await a((n) => r.DELETE("/account", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
   return e;
 }
-async function nt(n, t) {
-  const { data: i, error: e } = await s((r) => n.DELETE("/account", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
-}
-async function rt(n, t) {
-  const { data: i, error: e } = await s((r) => n.POST("/account/link", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function yt(r, t) {
+  const { data: e, error: i } = await a((n) => r.POST("/account/link", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-class ot {
+class pt {
   /**
    * Get account info.
    *
@@ -495,17 +497,17 @@ class ot {
    * @returns {Promise<AccountInfo>} A promise that resolves to the account information.
    */
   async AccountInfoGet(t) {
-    return await tt(this.apiClient, t);
+    return await lt(this.apiClient, t);
   }
   /**
    * Get account state.
    *
    * @param {TimeoutOptions} [params] - Optional parameters.
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
-   * @returns {Promise<AccountState>} A promise that resolves to the account state.
+   * @returns {Promise<AccountStatus>} A promise that resolves to the account state.
    */
   async AccountStateGet(t) {
-    return await Z(this.apiClient, t);
+    return await ht(this.apiClient, t);
   }
   /**
    * Get account profile.
@@ -515,18 +517,19 @@ class ot {
    * @returns {Promise<AccountProfile>} A promise that resolves to the account profile.
    */
   async AccountProfileGet(t) {
-    return await et(this.apiClient, t);
+    return await dt(this.apiClient, t);
   }
   /**
    * Set account profile.
    *
    * @param {SetAccountProfileParams} params - Parameters for setting the account profile.
-   *   @param {string} params.profile - Profile data string.
+   *   @param {string} params.profile - Profile name.
+   *   @param {string} [params.custom_url] - Custom profile URL.
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
   async AccountProfileSet(t) {
-    return await it(this.apiClient, t);
+    return await ft(this.apiClient, t);
   }
   /**
    * Unlink device from account. Removes association with the current account.
@@ -536,7 +539,7 @@ class ot {
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful unlinking.
    */
   async AccountUnlink(t) {
-    return await nt(this.apiClient, t);
+    return await wt(this.apiClient, t);
   }
   /**
    * Link device to account. Requests account link PIN. Works only if device is connected to MQTT and is not linked to account.
@@ -546,112 +549,123 @@ class ot {
    * @returns {Promise<AccountLink>} A promise that resolves to the link information (e.g., PIN).
    */
   async AccountLink(t) {
-    return await rt(this.apiClient, t);
+    return await yt(this.apiClient, t);
   }
 }
-async function st(n, t) {
-  const { appId: i, elements: e, priority: r = 6 } = t, { data: o, error: a } = await s(
-    (u) => n.POST("/display/draw", {
+async function mt(r, t) {
+  const { application_name: e, elements: i, priority: n = 50, timeout: s } = t, { data: o, error: h } = await a(
+    (c) => r.POST("/display/draw", {
       body: {
-        app_id: i,
-        priority: r,
-        elements: e
+        application_name: e,
+        priority: n,
+        elements: i
       },
-      signal: u
+      signal: c
     }),
-    t.timeout
+    s
   );
-  if (a)
-    throw a;
+  if (h)
+    throw h;
   return o;
 }
-async function at(n, t) {
-  const { data: i, error: e } = await s((r) => n.DELETE("/display/draw", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function Tt(r, t) {
+  const { data: e, error: i } = await a(
+    (n) => r.DELETE("/display/draw", {
+      params: {
+        query: {
+          application_name: t == null ? void 0 : t.application_name
+        }
+      },
+      signal: n
+    }),
+    t == null ? void 0 : t.timeout
+  );
+  if (i)
+    throw i;
+  return e;
 }
-async function ct(n, t) {
-  const { display: i } = t, { data: e, error: r } = await s(
-    (o) => n.GET("/screen", {
+async function Et(r, t) {
+  const { display: e, timeout: i } = t, { data: n, error: s } = await a(
+    (o) => r.GET("/screen", {
       params: {
         query: {
-          display: i
+          display: e
         }
       },
       parseAs: "blob",
       signal: o
     }),
-    t.timeout
+    i
   );
-  if (r)
-    throw r;
+  if (s)
+    throw s;
+  return n;
+}
+async function St(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/display/brightness", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
   return e;
 }
-async function ut(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/display/brightness", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
-}
-async function ht(n, t) {
-  const { value: i } = t, r = ((u) => {
-    if (typeof u == "number") {
-      if (u < 0 || u > 100)
+async function Ct(r, t) {
+  const { value: e } = t, n = ((h) => {
+    if (typeof h == "number") {
+      if (h < 0 || h > 100)
         throw new Error("Brightness value must be between 0 and 100 or 'auto'");
-      return String(u);
+      return String(h);
     }
-    if (u === "auto")
-      return "auto";
-  })(i), { data: o, error: a } = await s(
-    (u) => n.POST("/display/brightness", {
+    return "auto";
+  })(e), { data: s, error: o } = await a(
+    (h) => r.POST("/display/brightness", {
       params: {
         query: {
-          value: r
+          value: n
         }
       },
-      signal: u
+      signal: h
     }),
     t.timeout
   );
-  if (a)
-    throw a;
-  return o;
+  if (o)
+    throw o;
+  return s;
 }
-class dt {
+class kt {
   /**
-   * Draw on display. Starts the Canvas application if not running.
+   * Draw on display. Sends drawing data to the display. Supports JSON-defined display elements.
    *
    * @param {DrawParams} params - Parameters for the draw operation.
-   *   @param {DrawParams['appId']} params.appId - Application ID.
-   *   @param {DrawParams['elements']} params.elements - Display elements to draw.
-   *   @param {DrawParams['priority']} [params.priority=6] - Priority for the draw request (1-10).
+   *   @param {string} params.application_name - Application ID for organizing assets.
+   *   @param {Array} params.elements - Display elements to draw.
+   *   @param {number} [params.priority=50] - Draw priority in the range [1, 100].
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful draw command.
    */
   async DisplayDraw(t) {
-    return await st(this.apiClient, t);
+    return await mt(this.apiClient, t);
   }
   /**
-   * Clear display. Clears the display and stops the Canvas application if running.
+   * Clear display. Deletes display elements drawn by the Canvas application.
+   * If application_name is specified, only elements for that app are removed.
    *
-   * @param {TimeoutOptions} [params] - Optional parameters.
+   * @param {ClearParams} [params] - Optional parameters.
+   *   @param {string} [params.application_name] - Application identifier.
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful clear command.
    */
   async DisplayClear(t) {
-    return await at(this.apiClient, t);
+    return await Tt(this.apiClient, t);
   }
   /**
    * Get single frame for requested screen.
    *
    * @param {GetScreenFrameParams} params - Parameters for the frame request.
-   *   @param {string} params.display - Display identifier.
+   *   @param {number} params.display - Type of the display (Front = 0, Back = 1).
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<Blob>} A promise that resolves to the screen frame as a Blob.
    */
   async DisplayScreenFrameGet(t) {
-    return await ct(this.apiClient, t);
+    return await Et(this.apiClient, t);
   }
   /**
    * Get display brightness.
@@ -661,80 +675,80 @@ class dt {
    * @returns {Promise<DisplayBrightnessInfo>} A promise that resolves to the brightness information.
    */
   async DisplayBrightnessGet(t) {
-    return await ut(this.apiClient, t);
+    return await St(this.apiClient, t);
   }
   /**
    * Set display brightness.
    *
-   * @param {BrightnessParams} params - Brightness parameters:
-   *   @param {BrightnessParams['value']} [params.value] - Brightness (0-100 or "auto").
+   * @param {BrightnessParams} params - Brightness parameters.
+   *   @param {number | 'auto'} params.value - Brightness (0-100 or "auto").
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
   async DisplayBrightnessSet(t) {
-    return await ht(this.apiClient, t);
+    return await Ct(this.apiClient, t);
   }
 }
-async function ft(n, t) {
-  const { appId: i, path: e } = t, { data: r, error: o } = await s(
-    (a) => n.POST("/audio/play", {
+async function gt(r, t) {
+  const { application_name: e, path: i } = t, { data: n, error: s } = await a(
+    (o) => r.POST("/audio/play", {
       params: {
         query: {
-          app_id: i,
-          path: e
+          application_name: e,
+          path: i
         }
       },
-      signal: a
+      signal: o
     }),
     t.timeout
   );
-  if (o)
-    throw o;
-  return r;
-}
-async function wt(n, t) {
-  const { data: i, error: e } = await s((r) => n.DELETE("/audio/play", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+  if (s)
+    throw s;
+  return n;
+}
+async function At(r, t) {
+  const { data: e, error: i } = await a((n) => r.DELETE("/audio/play", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function lt(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/audio/volume", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function bt(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/audio/volume", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function yt(n, t) {
-  const { volume: i } = t;
-  if (typeof i != "number" || i < 0 || i > 100)
+async function _t(r, t) {
+  const { volume: e } = t;
+  if (typeof e != "number" || e < 0 || e > 100)
     throw new Error("Volume must be a number between 0 and 100");
-  const { data: e, error: r } = await s(
-    (o) => n.POST("/audio/volume", {
+  const { data: i, error: n } = await a(
+    (s) => r.POST("/audio/volume", {
       params: {
         query: {
-          volume: i
+          volume: e
         }
       },
-      signal: o
+      signal: s
     }),
     t.timeout
   );
-  if (r)
-    throw r;
-  return e;
+  if (n)
+    throw n;
+  return i;
 }
-class pt {
+class Rt {
   /**
    * Play audio file. Plays a file from internal storage.
    *
    * @param {AudioPlayParams} params - Parameters for audio playback.
-   *   @param {string} params.appId - Application ID.
+   *   @param {string} params.application_name - Application name.
    *   @param {string} params.path - Path to the audio file.
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful play command.
    */
   async AudioPlay(t) {
-    return await ft(this.apiClient, t);
+    return await gt(this.apiClient, t);
   }
   /**
    * Stop audio playback. Stops any currently playing audio.
@@ -744,7 +758,7 @@ class pt {
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful stop command.
    */
   async AudioStop(t) {
-    return await wt(this.apiClient, t);
+    return await At(this.apiClient, t);
   }
   /**
    * Get audio volume.
@@ -754,7 +768,7 @@ class pt {
    * @returns {Promise<AudioVolumeInfo>} A promise that resolves to the audio volume information.
    */
   async AudioVolumeGet(t) {
-    return await lt(this.apiClient, t);
+    return await bt(this.apiClient, t);
   }
   /**
    * Set audio volume.
@@ -765,50 +779,45 @@ class pt {
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
   async AudioVolumeSet(t) {
-    return await yt(this.apiClient, t);
+    return await _t(this.apiClient, t);
   }
 }
-async function St(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/wifi/status", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function Dt(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/wifi/status", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function Tt(n, t) {
-  const { data: i, error: e } = await s(
-    (r) => n.POST("/wifi/connect", {
+async function vt(r, t) {
+  const { ssid: e, password: i, security: n, ip_config: s } = t, { data: o, error: h } = await a(
+    (c) => r.POST("/wifi/connect", {
       body: {
-        ssid: t.ssid,
-        password: t.password,
-        security: t.security,
-        ip_config: {
-          ip_method: t.ipConfig.ipMethod,
-          address: t.ipConfig.address,
-          mask: t.ipConfig.mask,
-          gateway: t.ipConfig.gateway
-        }
+        ssid: e,
+        password: i,
+        security: n,
+        ip_config: s
       },
-      signal: r
+      signal: c
     }),
     t.timeout
   );
-  if (e)
-    throw e;
-  return i;
+  if (h)
+    throw h;
+  return o;
 }
-async function Et(n, t) {
-  const { data: i, error: e } = await s((r) => n.POST("/wifi/disconnect", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function Pt(r, t) {
+  const { data: e, error: i } = await a((n) => r.POST("/wifi/disconnect", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function mt(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/wifi/networks", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function Ot(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/wifi/networks", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-class Ct {
+class Ut {
   /**
    * Returns current Wi-Fi status.
    *
@@ -817,7 +826,7 @@ class Ct {
    * @returns {Promise<WifiStatusResponse>} A promise that resolves to the Wi-Fi status.
    */
   async WifiStatusGet(t) {
-    return await St(this.apiClient, t);
+    return await Dt(this.apiClient, t);
   }
   /**
    * Connects to Wi-Fi network.
@@ -826,12 +835,12 @@ class Ct {
    *   @param {string} params.ssid - Network SSID.
    *   @param {string} params.password - Network password.
    *   @param {WifiSecurityMethod} params.security - Security method.
-   *   @param {object} params.ipConfig - IP configuration.
+   *   @param {object} [params.ip_config] - IP configuration.
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful connection initiation.
    */
   async WifiConnect(t) {
-    return await Tt(this.apiClient, t);
+    return await vt(this.apiClient, t);
   }
   /**
    * Disconnects from Wi-Fi.
@@ -841,7 +850,7 @@ class Ct {
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful disconnection.
    */
   async WifiDisconnect(t) {
-    return await Et(this.apiClient, t);
+    return await Pt(this.apiClient, t);
   }
   /**
    * Scans environment for available Wi-Fi networks.
@@ -851,118 +860,118 @@ class Ct {
    * @returns {Promise<WifiNetworkResponse>} A promise that resolves to a list of available networks.
    */
   async WifiNetworksGet(t) {
-    return await mt(this.apiClient, t);
+    return await Ot(this.apiClient, t);
   }
 }
-async function kt(n, t) {
-  const { path: i, file: e } = t, { data: r, error: o } = await s(
-    (a) => n.POST("/storage/write", {
+async function It(r, t) {
+  const { path: e, file: i } = t, { data: n, error: s } = await a(
+    (o) => r.POST("/storage/write", {
       params: {
         query: {
-          path: i
+          path: e
         }
       },
       headers: {
         "Content-Type": "application/octet-stream"
       },
-      body: e,
-      signal: a
+      body: i,
+      signal: o
     }),
     t.timeout
   );
-  if (o)
-    throw o;
-  return r;
+  if (s)
+    throw s;
+  return n;
 }
-async function gt(n, t) {
-  const { path: i, asArrayBuffer: e } = t, { data: r, error: o } = await s(
-    (a) => n.GET("/storage/read", {
+async function Lt(r, t) {
+  const { path: e, as_array_buffer: i } = t, { data: n, error: s } = await a(
+    (o) => r.GET("/storage/read", {
       params: {
         query: {
-          path: i
+          path: e
         }
       },
-      parseAs: e ? "arrayBuffer" : "blob",
-      signal: a
+      parseAs: i ? "arrayBuffer" : "blob",
+      signal: o
     }),
     t.timeout
   );
-  if (o)
-    throw o;
-  return r;
+  if (s)
+    throw s;
+  return n;
 }
-async function At(n, t) {
-  const { path: i } = t, { data: e, error: r } = await s(
-    (o) => n.GET("/storage/list", {
+async function Nt(r, t) {
+  const { path: e } = t, { data: i, error: n } = await a(
+    (s) => r.GET("/storage/list", {
       params: {
         query: {
-          path: i
+          path: e
         }
       },
-      signal: o
+      signal: s
     }),
     t.timeout
   );
-  if (r)
-    throw r;
-  return e;
+  if (n)
+    throw n;
+  return i;
 }
-async function bt(n, t) {
-  const { path: i } = t, { data: e, error: r } = await s(
-    (o) => n.DELETE("/storage/remove", {
+async function Gt(r, t) {
+  const { path: e } = t, { data: i, error: n } = await a(
+    (s) => r.DELETE("/storage/remove", {
       params: {
         query: {
-          path: i
+          path: e
         }
       },
-      signal: o
+      signal: s
     }),
     t.timeout
   );
-  if (r)
-    throw r;
-  return e;
+  if (n)
+    throw n;
+  return i;
 }
-async function vt(n, t) {
-  const { path: i } = t, { data: e, error: r } = await s(
-    (o) => n.POST("/storage/mkdir", {
+async function xt(r, t) {
+  const { path: e } = t, { data: i, error: n } = await a(
+    (s) => r.POST("/storage/mkdir", {
       params: {
         query: {
-          path: i
+          path: e
         }
       },
-      signal: o
+      signal: s
     }),
     t.timeout
   );
-  if (r)
-    throw r;
-  return e;
-}
-async function Gt(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/storage/status", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
+  if (n)
+    throw n;
   return i;
 }
-async function Pt(n, t) {
-  const { path: i, new_path: e } = t, { data: r, error: o } = await s(
-    (a) => n.POST("/storage/rename", {
+async function Bt(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/storage/status", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
+}
+async function Ft(r, t) {
+  const { path: e, new_path: i } = t, { data: n, error: s } = await a(
+    (o) => r.POST("/storage/rename", {
       params: {
         query: {
-          path: i,
-          new_path: e
+          path: e,
+          new_path: i
         }
       },
-      signal: a
+      signal: o
     }),
     t.timeout
   );
-  if (o)
-    throw o;
-  return r;
+  if (s)
+    throw s;
+  return n;
 }
-class Lt {
+class Wt {
   /**
    * Upload file to internal storage. Uploads a file to a specified path.
    *
@@ -973,19 +982,19 @@ class Lt {
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful upload.
    */
   async StorageWrite(t) {
-    return await kt(this.apiClient, t);
+    return await It(this.apiClient, t);
   }
   /**
    * Download file from internal storage. Downloads a file from a specified path.
    *
    * @param {DownloadFileParams} params - Download parameters:
    *   @param {string} params.path - Path to the file.
-   *   @param {boolean} [params.asArrayBuffer] - Whether to return ArrayBuffer instead of Blob.
+   *   @param {boolean} [params.as_array_buffer] - Whether to return ArrayBuffer instead of Blob.
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<StorageReadResponse>} A promise that resolves to the file content (Blob or ArrayBuffer).
    */
   async StorageRead(t) {
-    return await gt(this.apiClient, t);
+    return await Lt(this.apiClient, t);
   }
   /**
    * List files on internal storage.
@@ -996,7 +1005,7 @@ class Lt {
    * @returns {Promise<StorageList>} A promise that resolves to a list of files and directories.
    */
   async StorageListGet(t) {
-    return await At(this.apiClient, t);
+    return await Nt(this.apiClient, t);
   }
   /**
    * Remove a file on internal storage. Removes a file with a specified path.
@@ -1007,7 +1016,7 @@ class Lt {
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful removal.
    */
   async StorageRemove(t) {
-    return await bt(this.apiClient, t);
+    return await Gt(this.apiClient, t);
   }
   /**
    * Create a directory on internal storage. Creates a new directory with a specified path.
@@ -1018,7 +1027,7 @@ class Lt {
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful creation.
    */
   async StorageMkdir(t) {
-    return await vt(this.apiClient, t);
+    return await xt(this.apiClient, t);
   }
   /**
    * Show storage usage.
@@ -1028,7 +1037,7 @@ class Lt {
    * @returns {Promise<StorageStatus>} A promise that resolves to the storage status.
    */
   async StorageStatusGet(t) {
-    return await Gt(this.apiClient, t);
+    return await Bt(this.apiClient, t);
   }
   /**
    * Rename/move a file. Moves a file to a new location.
@@ -1040,54 +1049,54 @@ class Lt {
    * @returns {Promise<SuccessResponse>} A promise that resolves on successful rename.
    */
   async StorageRename(t) {
-    return await Pt(this.apiClient, t);
+    return await Ft(this.apiClient, t);
   }
 }
-async function Ot(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/access", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function Mt(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/access", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function Dt(n, t) {
-  let { mode: i, key: e } = t;
-  if (e = e ?? "", String(e).trim() && !/^\d{4,10}$/.test(String(e)))
+async function $t(r, t) {
+  const { mode: e, key: i } = t, n = i ?? "";
+  if (String(n).trim() && !/^\d{4,10}$/.test(String(n)))
     throw new Error("Key must be a string of 4 to 10 digits");
-  const { data: r, error: o } = await s(
-    (a) => n.POST("/access", {
+  const { data: s, error: o } = await a(
+    (h) => r.POST("/access", {
       params: {
         query: {
-          mode: i,
-          key: e
+          mode: e,
+          key: n
         }
       },
-      signal: a
+      signal: h
     }),
     t.timeout
   );
   if (o)
     throw o;
-  return r;
+  return s;
 }
-async function Ut(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/name", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function Kt(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/name", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function Bt(n, t) {
-  const { data: i, error: e } = await s(
-    (r) => n.POST("/name", {
-      body: t,
-      signal: r
+async function zt(r, t) {
+  const { name: e } = t, { data: i, error: n } = await a(
+    (s) => r.POST("/name", {
+      body: { name: e },
+      signal: s
     }),
     t.timeout
   );
-  if (e)
-    throw e;
+  if (n)
+    throw n;
   return i;
 }
-class It {
+class Ht {
   /**
    * Get HTTP API access over Wi-Fi configuration.
    *
@@ -1096,20 +1105,20 @@ class It {
    * @returns {Promise<HttpAccessInfo>} A promise that resolves to the access configuration.
    */
   async SettingsAccessGet(t) {
-    return await Ot(this.apiClient, t);
+    return await Mt(this.apiClient, t);
   }
   /**
    * Set HTTP API access over Wi-Fi configuration.
    *
    * @param {HttpAccessParams} params - Access parameters:
    *   @param {boolean} params.mode - Enable/disable access.
-   *   @param {string} params.key - Access key (4-10 digits).
+   *   @param {string} [params.key] - Access key (4-10 digits).
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
   async SettingsAccessSet(t) {
-    const i = await Dt(this.apiClient, t);
-    return t.mode === "key" && t.key && this.setApiKey(t.key), i;
+    const e = await $t(this.apiClient, t);
+    return t.mode === "key" && t.key && this.setApiKey(t.key), e;
   }
   /**
    * Get current device name.
@@ -1119,7 +1128,7 @@ class It {
    * @returns {Promise<NameInfo>} A promise that resolves to the device name.
    */
   async SettingsNameGet(t) {
-    return await Ut(this.apiClient, t);
+    return await Kt(this.apiClient, t);
   }
   /**
    * Set device name.
@@ -1130,34 +1139,34 @@ class It {
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
   async SettingsNameSet(t) {
-    return await Bt(this.apiClient, t);
+    return await zt(this.apiClient, t);
   }
 }
-async function $t(n, t) {
-  const { data: i, error: e } = await s((r) => n.POST("/ble/enable", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function qt(r, t) {
+  const { data: e, error: i } = await a((n) => r.POST("/ble/enable", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function Rt(n, t) {
-  const { data: i, error: e } = await s((r) => n.POST("/ble/disable", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function Vt(r, t) {
+  const { data: e, error: i } = await a((n) => r.POST("/ble/disable", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function Kt(n, t) {
-  const { data: i, error: e } = await s((r) => n.DELETE("/ble/pairing", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function Xt(r, t) {
+  const { data: e, error: i } = await a((n) => r.DELETE("/ble/pairing", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function Ft(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/ble/status", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function jt(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/ble/status", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-class _t {
+class Yt {
   /**
    * Enable BLE. Starts advertising.
    *
@@ -1166,7 +1175,7 @@ class _t {
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
   async BleEnable(t) {
-    return await $t(this.apiClient, t);
+    return await qt(this.apiClient, t);
   }
   /**
    * Disable BLE. Stops advertising.
@@ -1176,7 +1185,7 @@ class _t {
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
   async BleDisable(t) {
-    return await Rt(this.apiClient, t);
+    return await Vt(this.apiClient, t);
   }
   /**
    * Remove pairing. Remove pairing with previous device.
@@ -1186,7 +1195,7 @@ class _t {
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
   async BleUnpair(t) {
-    return await Kt(this.apiClient, t);
+    return await Xt(this.apiClient, t);
   }
   /**
    * Returns current BLE status.
@@ -1196,169 +1205,218 @@ class _t {
    * @returns {Promise<BleStatusResponse>} A promise that resolves to the BLE status.
    */
   async BleStatusGet(t) {
-    return await Ft(this.apiClient, t);
+    return await jt(this.apiClient, t);
   }
 }
-async function Wt(n, t) {
-  const { keyName: i } = t, { data: e, error: r } = await s(
-    (o) => n.POST("/input", {
+async function Jt(r, t) {
+  const { key: e } = t, { data: i, error: n } = await a(
+    (s) => r.POST("/input", {
       params: {
         query: {
-          key: i
+          key: e
         }
       },
-      signal: o
+      signal: s
     }),
     t.timeout
   );
-  if (r)
-    throw r;
-  return e;
+  if (n)
+    throw n;
+  return i;
 }
-class Mt {
+class Qt {
   /**
    * Send input event. Send single key press event.
    *
    * @param {InputKeyParams} params - Button press parameters:
-   *   @param {KeyName} params.keyName - Name of the key to press.
+   *   @param {KeyName} params.key - Key name.
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
   async InputSend(t) {
-    return await Wt(this.apiClient, t);
+    return await Jt(this.apiClient, t);
   }
 }
-async function Nt(n, t) {
-  const { data: i, error: e } = await s((r) => n.GET("/matter/commissioning", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function Zt(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/smart_home/pairing", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function qt(n, t) {
-  const { data: i, error: e } = await s((r) => n.POST("/matter/commissioning", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function te(r, t) {
+  const { data: e, error: i } = await a((n) => r.POST("/smart_home/pairing", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-async function xt(n, t) {
-  const { data: i, error: e } = await s((r) => n.DELETE("/matter/commissioning", { signal: r }), t == null ? void 0 : t.timeout);
-  if (e)
-    throw e;
-  return i;
+async function ee(r, t) {
+  const { data: e, error: i } = await a((n) => r.DELETE("/smart_home/pairing", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
+}
+async function ie(r, t) {
+  const { data: e, error: i } = await a((n) => r.GET("/smart_home/switch", { signal: n }), t == null ? void 0 : t.timeout);
+  if (i)
+    throw i;
+  return e;
 }
-class Vt {
+async function re(r, t) {
+  const { timeout: e, ...i } = t, { data: n, error: s } = await a((o) => r.POST("/smart_home/switch", { body: i, signal: o }), e);
+  if (s)
+    throw s;
+  return n;
+}
+class ne {
   /**
-   * Get Matter status.
+   * Smart home commissioning status.
    *
    * @param {TimeoutOptions} [params] - Optional parameters.
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
-   * @returns {Promise<MatterStatus>} A promise that resolves to the Matter status.
+   * @returns {Promise<SmartHomePairingInfo>} A promise that resolves to the pairing info.
    */
-  async MatterStatusGet(t) {
-    return await Nt(this.apiClient, t);
+  async SmartHomePairingGet(t) {
+    return await Zt(this.apiClient, t);
+  }
+  /**
+   * Link device to a smart home.
+   *
+   * @param {TimeoutOptions} [params] - Optional timeout.
+   * @returns {Promise<SmartHomePairingPayload>} A promise that resolves to the pairing payload.
+   */
+  async SmartHomePair(t) {
+    return await te(this.apiClient, t);
   }
   /**
-   * Pair Matter device.
+   * Erase all smart home links.
    *
    * @param {TimeoutOptions} [params] - Optional parameters.
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
-   * @returns {Promise<MatterPairingInfo>} A promise that resolves on success.
+   * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
-  async MatterPair(t) {
-    return await qt(this.apiClient, t);
+  async SmartHomeErase(t) {
+    return await ee(this.apiClient, t);
   }
   /**
-   * Erase Matter devices.
+   * Get state of emulated smart home switch.
    *
    * @param {TimeoutOptions} [params] - Optional parameters.
    *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
+   * @returns {Promise<SmartHomeSwitchState>} A promise that resolves to the switch state.
+   */
+  async SmartHomeSwitchStateGet(t) {
+    return await ie(this.apiClient, t);
+  }
+  /**
+   * Set state of emulated smart home switch.
+   *
+   * @param {SmartHomeSwitchState & TimeoutOptions} params - Switch state and optional timeout.
    * @returns {Promise<SuccessResponse>} A promise that resolves on success.
    */
+  async SmartHomeSwitchStateSet(t) {
+    return await re(this.apiClient, t);
+  }
+  // ALIASES for backward compatibility (Matter -> SmartHome)
+  /**
+   * @deprecated Use SmartHomePairingGet instead.
+   */
+  async MatterStatusGet(t) {
+    return await this.SmartHomePairingGet(t);
+  }
+  /**
+   * @deprecated Use SmartHomePair instead.
+   */
+  async MatterPair(t) {
+    return await this.SmartHomePair(t);
+  }
+  /**
+   * @deprecated Use SmartHomeErase instead.
+   */
   async MatterErase(t) {
-    return await xt(this.apiClient, t);
+    return await this.SmartHomeErase(t);
   }
 }
-async function jt(n, t) {
-  const { appId: i, fileName: e, file: r } = t, { data: o, error: a } = await s(
-    (u) => n.POST("/assets/upload", {
+async function se(r, t) {
+  const { application_name: e, file: i, data: n } = t, { data: s, error: o } = await a(
+    (h) => r.POST("/assets/upload", {
       params: {
         query: {
-          app_id: i,
-          file: e
+          application_name: e,
+          file: i
         }
       },
       headers: {
         "Content-Type": "application/octet-stream"
       },
-      body: r,
-      signal: u
+      body: n,
+      signal: h
     }),
     t.timeout
   );
-  if (a)
-    throw a;
-  return o;
+  if (o)
+    throw o;
+  return s;
 }
-async function zt(n, t) {
-  const { appId: i } = t, { data: e, error: r } = await s(
-    (o) => n.DELETE("/assets/upload", {
+async function ae(r, t) {
+  const { application_name: e } = t, { data: i, error: n } = await a(
+    (s) => r.DELETE("/assets/upload", {
       params: {
         query: {
-          app_id: i
+          application_name: e
         }
       },
-      signal: o
+      signal: s
     }),
     t.timeout
   );
-  if (r)
-    throw r;
-  return e;
+  if (n)
+    throw n;
+  return i;
 }
-class Ht {
+class oe {
   /**
    * Upload asset file with app ID. Uploads a file to a specific app's assets directory.
    *
    * @param {UploadParams} params - Parameters for the upload.
-   *   @param {UploadParams['appId']} params.appId - Application ID for organizing assets.
-   *   @param {UploadParams['fileName']} params.fileName - Filename for the uploaded asset.
-   *   @param {UploadParams['file']} params.file - File data to upload.
-   *   @param {UploadParams['timeout']} [params.timeout] - Request timeout in milliseconds.
+   *   @param {string} params.application_name - Application name for organizing assets.
+   *   @param {string} params.file - Filename for the uploaded asset.
+   *   @param {BusyFile} params.data - File data to upload.
+   *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<SuccessResponse>} Result of the upload operation.
    */
   async AssetsUpload(t) {
-    return await jt(this.apiClient, t);
+    return await se(this.apiClient, t);
   }
   /**
    * Delete app assets. Deletes all assets for a specific app ID.
    *
    * @param {DeleteParams} params - Parameters for the delete.
-   *   @param {DeleteParams['appId']} params.appId - Application ID whose assets should be deleted.
-   *   @param {DeleteParams['timeout']} [params.timeout] - Request timeout in milliseconds.
+   *   @param {string} params.application_name - Application name whose assets should be deleted.
+   *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
    * @returns {Promise<SuccessResponse>} Result of the delete operation.
    */
   async AssetsDelete(t) {
-    return await zt(this.apiClient, t);
+    return await ae(this.apiClient, t);
   }
 }
-const S = "http://10.0.4.20", Jt = "https://proxy.busy.app", Xt = /^https?:\/\/proxy(?:\.(?:dev|test|stage))?\.busy\.app$/i;
-function T(n) {
-  const t = n.split(".");
+const D = "http://10.0.4.20", ce = "https://proxy.busy.app", ue = /^https?:\/\/proxy(?:\.(?:dev|test|stage))?\.busy\.app$/i;
+function v(r) {
+  const t = r.split(".");
   if (t.length !== 4)
     return !1;
-  for (const i of t) {
-    if (i.length === 0 || i.length > 1 && i[0] === "0" || !/^\d+$/.test(i))
+  for (const e of t) {
+    if (e.length === 0 || e.length > 1 && e[0] === "0" || !/^\d+$/.test(e))
       return !1;
-    const e = Number(i);
-    if (e < 0 || e > 255)
+    const i = Number(e);
+    if (i < 0 || i > 255)
       return !1;
   }
   return !0;
 }
-function E(n) {
-  return /\.local$/i.test(n);
+function P(r) {
+  return /\.local$/i.test(r);
 }
-class Yt {
+class he {
   /**
    * Creates an instance of BUSY Bar.
    * Initializes the API client with the provided host address.
@@ -1387,38 +1445,38 @@ class Yt {
      * @type {BusyBarConfig['host']}
      * @readonly
      */
-    c(this, "addr");
+    u(this, "addr");
     /**
      * Current API semantic version.
      * @type {ApiSemver}
      */
-    c(this, "apiSemver");
+    u(this, "apiSemver");
     /**
      * API Client instance.
      */
-    c(this, "apiClient");
-    c(this, "setApiKeyFn");
-    c(this, "setTokenFn");
+    u(this, "apiClient");
+    u(this, "setApiKeyFn");
+    u(this, "setTokenFn");
     /**
      * Detected connection type based on auth requirements.
      * - "wifi": Device requires authentication (returned 401/403).
      * - "usb": Device allows access without token (returned 200).
      * - "unknown": Detection failed or not yet completed.
      */
-    c(this, "connectionType", "unknown");
+    u(this, "connectionType", "unknown");
     if (!t || !t.addr && !t.token)
-      this.addr = S;
+      this.addr = D;
     else if (!t.addr)
-      this.addr = Jt;
+      this.addr = ce;
     else {
-      let o = t.addr.trim();
-      if (/^https?:\/\//i.test(o) || (o = `http://${o}`), Xt.test(o) && !t.token)
+      let s = t.addr.trim();
+      if (/^https?:\/\//i.test(s) || (s = `http://${s}`), ue.test(s) && !t.token)
         throw new Error("Token is required. Please provide it.");
-      this.addr = o;
+      this.addr = s;
     }
     this.apiSemver = "";
-    const { client: i, setApiKey: e, setToken: r } = O(`${this.addr}/api/`, this.SystemVersionGet.bind(this), t == null ? void 0 : t.token);
-    this.apiClient = i, this.setApiKeyFn = e, this.setTokenFn = r, this.detectConnectionType();
+    const { client: e, setApiKey: i, setToken: n } = M(`${this.addr}/api/`, this.SystemVersionGet.bind(this), t == null ? void 0 : t.token);
+    this.apiClient = e, this.setApiKeyFn = i, this.setTokenFn = n, this.detectConnectionType();
   }
   /**
    * Probes the device to determine connection type.
@@ -1426,23 +1484,23 @@ class Yt {
    */
   async detectConnectionType() {
     const t = new URL(this.addr).hostname;
-    if (!T(t) && !E(t)) {
+    if (!v(t) && !P(t)) {
       this.connectionType = "wifi";
       return;
     }
-    const i = m({
+    const e = O({
       baseUrl: `${this.addr}/api/`
     });
     try {
-      const { response: e } = await i.GET("/name");
-      if (e.status === 401 || e.status === 403)
+      const { response: i } = await e.GET("/name");
+      if (i.status === 401 || i.status === 403)
         this.connectionType = "wifi";
-      else if (e.ok)
+      else if (i.ok)
         this.connectionType = "usb";
       else
-        throw new Error(`Failed to detect connection type. Status: ${e.status}`);
-    } catch (e) {
-      throw e;
+        throw new Error(`Failed to detect connection type. Status: ${i.status}`);
+    } catch (i) {
+      throw i;
     }
   }
   /**
@@ -1460,95 +1518,95 @@ class Yt {
     this.setTokenFn(t);
   }
 }
-function Qt(n, t) {
-  t.forEach((i) => {
-    Object.getOwnPropertyNames(i.prototype).forEach((e) => {
-      Object.defineProperty(n.prototype, e, Object.getOwnPropertyDescriptor(i.prototype, e) || /* @__PURE__ */ Object.create(null));
+function le(r, t) {
+  t.forEach((e) => {
+    Object.getOwnPropertyNames(e.prototype).forEach((i) => {
+      Object.defineProperty(r.prototype, i, Object.getOwnPropertyDescriptor(e.prototype, i) || /* @__PURE__ */ Object.create(null));
     });
   });
 }
-Qt(Yt, [
-  K,
-  j,
-  Q,
-  ot,
-  dt,
+le(he, [
+  X,
+  rt,
+  ut,
   pt,
-  Ct,
-  Lt,
-  It,
-  _t,
-  Mt,
-  Vt,
-  Ht
+  kt,
+  Rt,
+  Ut,
+  Wt,
+  Ht,
+  Yt,
+  Qt,
+  ne,
+  oe
 ]);
-var p = /* @__PURE__ */ ((n) => (n[n.FRONT = 0] = "FRONT", n[n.BACK = 1] = "BACK", n))(p || {});
-const C = 3e3, k = /* @__PURE__ */ new Set([1001, 1006, 1012, 1013, 1014, 3008]);
-function g(n, t) {
-  if (t < 0 || t >= n.length)
-    throw new Error(`Index ${t} is out of bounds (0…${n.length - 1})`);
-  const i = n[t];
-  if (i === void 0)
+var _ = /* @__PURE__ */ ((r) => (r[r.FRONT = 0] = "FRONT", r[r.BACK = 1] = "BACK", r))(_ || {});
+const U = 3e3, I = /* @__PURE__ */ new Set([1001, 1006, 1012, 1013, 1014, 3008]);
+function L(r, t) {
+  if (t < 0 || t >= r.length)
+    throw new Error(`Index ${t} is out of bounds (0…${r.length - 1})`);
+  const e = r[t];
+  if (e === void 0)
     throw new Error(`Unexpected undefined at index ${t}`);
-  return i;
+  return e;
 }
-function Zt(n, t) {
-  let i = 0;
-  const e = n.length, r = [];
-  for (; i < e; ) {
-    const o = g(n, i);
-    if (i += 1, (o & 128) !== 0) {
-      const a = o & 127;
-      for (let u = 0; u < a * t; u++)
-        r.push(n[i + u]);
-      i += a * t;
+function de(r, t) {
+  let e = 0;
+  const i = r.length, n = [];
+  for (; e < i; ) {
+    const s = L(r, e);
+    if (e += 1, (s & 128) !== 0) {
+      const o = s & 127;
+      for (let h = 0; h < o * t; h++)
+        n.push(r[e + h]);
+      e += o * t;
     } else {
-      const a = o, u = n.slice(i, i + t);
-      for (let w = 0; w < a; w++)
-        for (let f = 0; f < t; f++)
-          r.push(u[f]);
-      i += t;
+      const o = s, h = r.slice(e, e + t);
+      for (let c = 0; c < o; c++)
+        for (let p = 0; p < t; p++)
+          n.push(h[p]);
+      e += t;
     }
   }
-  return new Uint8Array(r);
+  return new Uint8Array(n);
 }
-function te(n) {
-  const t = new Uint8Array(n.length * 2);
-  let i = 0, e = 0;
-  for (; i < n.length; ) {
-    const r = g(n, i), o = r & 15, a = r >> 4 & 15;
-    t[e] = o, t[e + 1] = a, i += 1, e += 2;
+function fe(r) {
+  const t = new Uint8Array(r.length * 2);
+  let e = 0, i = 0;
+  for (; e < r.length; ) {
+    const n = L(r, e), s = n & 15, o = n >> 4 & 15;
+    t[i] = s, t[i + 1] = o, e += 1, i += 2;
   }
   return t;
 }
-const A = () => typeof window < "u" && typeof window.document < "u";
-class ne {
+const N = () => typeof window < "u" && typeof window.document < "u";
+class me {
   constructor(t) {
-    c(this, "addr");
-    c(this, "connected", !1);
+    u(this, "addr");
+    u(this, "connected", !1);
     // @ts-ignore
-    c(this, "apiKey");
+    u(this, "apiKey");
     // @ts-ignore
-    c(this, "apiSemver");
-    c(this, "dataListeners", []);
-    c(this, "stopListeners", []);
-    c(this, "errorListeners", []);
-    c(this, "socket", null);
-    if (this.config = t, !A())
+    u(this, "apiSemver");
+    u(this, "dataListeners", []);
+    u(this, "stopListeners", []);
+    u(this, "errorListeners", []);
+    u(this, "socket", null);
+    if (this.config = t, !N())
       throw new Error("not browser");
     if (t.apiKey && (this.apiKey = t.apiKey), t.apiSemver && (this.apiSemver = t.apiSemver), !t || !t.addr)
-      this.addr = S;
+      this.addr = D;
     else {
-      let i = t.addr.trim();
-      /^https?:\/\//i.test(i) || (i = `http://${i}`);
+      let e = t.addr.trim();
+      /^https?:\/\//i.test(e) || (e = `http://${e}`);
       try {
-        const r = new URL(i).hostname;
-        if (!T(r) && !E(r))
+        const n = new URL(e).hostname;
+        if (!v(n) && !P(n))
           throw new Error(`Invalid address: "${t.addr}". Only IP addresses and mDNS names (ending in .local) are supported.`);
-      } catch (e) {
-        throw e instanceof Error && e.message.startsWith("Invalid address") ? e : new Error(`Invalid URL format: "${t.addr}"`);
+      } catch (i) {
+        throw i instanceof Error && i.message.startsWith("Invalid address") ? i : new Error(`Invalid URL format: "${t.addr}"`);
       }
-      this.addr = i;
+      this.addr = e;
     }
   }
   onData(t) {
@@ -1561,16 +1619,16 @@ class ne {
     this.errorListeners.push(t);
   }
   emitData(t) {
-    for (const i of this.dataListeners)
-      i(t);
+    for (const e of this.dataListeners)
+      e(t);
   }
   emitStop() {
     for (const t of this.stopListeners)
       t();
   }
   emitError(t) {
-    for (const i of this.errorListeners)
-      i(t);
+    for (const e of this.errorListeners)
+      e(t);
   }
   async openWebsocket() {
     this.socket && await this.closeWebsocket();
@@ -1579,35 +1637,35 @@ class ne {
       throw new Error("The WebSocket URL is not specified");
     this.socket = new WebSocket(t), this.socket.onopen = () => {
       this.socket && (this.socket.send(JSON.stringify({ display: this.config.deviceScreen })), this.connected = !0);
-    }, this.socket.binaryType = "arraybuffer", this.socket.onmessage = (i) => {
+    }, this.socket.binaryType = "arraybuffer", this.socket.onmessage = (e) => {
       try {
-        if (typeof i.data == "string")
+        if (typeof e.data == "string")
           return;
-        const e = new Uint8Array(i.data);
-        let r;
-        const o = this.config.deviceScreen === p.FRONT ? 3 : 2;
+        const i = new Uint8Array(e.data);
+        let n;
+        const s = this.config.deviceScreen === _.FRONT ? 3 : 2;
         try {
-          const a = Zt(e, o);
-          this.config.deviceScreen === p.BACK ? r = te(a) : r = a, this.emitData(r);
+          const o = de(i, s);
+          this.config.deviceScreen === _.BACK ? n = fe(o) : n = o, this.emitData(n);
         } catch {
-          this.emitData(e);
+          this.emitData(i);
         }
       } catch {
         this.connected = !1, this.emitStop();
       }
-    }, this.socket.onerror = (i) => {
+    }, this.socket.onerror = (e) => {
       this.connected = !1, this.emitError({
         code: 1006,
         // Standard «abnormal closure» code per RFC-6455
         message: "WebSocket error occurred",
-        raw: i
+        raw: e
       }), this.emitStop();
-    }, this.socket.onclose = async (i) => {
-      if (this.socket = null, this.connected = !1, i.code === C || k.has(i.code)) {
+    }, this.socket.onclose = async (e) => {
+      if (this.socket = null, this.connected = !1, e.code === U || I.has(e.code)) {
         this.emitError({
-          code: i.code,
-          message: i.reason,
-          raw: i
+          code: e.code,
+          message: e.reason,
+          raw: e
         });
         return;
       }
@@ -1622,34 +1680,34 @@ class ne {
     });
   }
 }
-class re {
+class Te {
   constructor(t) {
-    c(this, "addr");
-    c(this, "connected", !1);
+    u(this, "addr");
+    u(this, "connected", !1);
     // @ts-ignore
-    c(this, "apiKey");
+    u(this, "apiKey");
     // @ts-ignore
-    c(this, "apiSemver");
-    c(this, "inputEvent");
-    c(this, "dataListeners", []);
-    c(this, "stopListeners", []);
-    c(this, "errorListeners", []);
-    c(this, "socket", null);
-    if (!A())
+    u(this, "apiSemver");
+    u(this, "inputEvent");
+    u(this, "dataListeners", []);
+    u(this, "stopListeners", []);
+    u(this, "errorListeners", []);
+    u(this, "socket", null);
+    if (!N())
       throw new Error("not browser");
     if (t != null && t.apiKey && (this.apiKey = t.apiKey), t != null && t.apiSemver && (this.apiSemver = t.apiSemver), !t || !t.addr)
-      this.addr = S;
+      this.addr = D;
     else {
-      let i = t.addr.trim();
-      /^https?:\/\//i.test(i) || (i = `http://${i}`);
+      let e = t.addr.trim();
+      /^https?:\/\//i.test(e) || (e = `http://${e}`);
       try {
-        const r = new URL(i).hostname;
-        if (!T(r) && !E(r))
+        const n = new URL(e).hostname;
+        if (!v(n) && !P(n))
           throw new Error(`Invalid address: "${t.addr}". Only IP addresses and mDNS names (ending in .local) are supported.`);
-      } catch (e) {
-        throw e instanceof Error && e.message.startsWith("Invalid address") ? e : new Error(`Invalid URL format: "${t.addr}"`);
+      } catch (i) {
+        throw i instanceof Error && i.message.startsWith("Invalid address") ? i : new Error(`Invalid URL format: "${t.addr}"`);
       }
-      this.addr = i;
+      this.addr = e;
     }
     this.inputEvent = {};
   }
@@ -1663,16 +1721,16 @@ class re {
     this.errorListeners.push(t);
   }
   emitData(t) {
-    for (const i of this.dataListeners)
-      i(t);
+    for (const e of this.dataListeners)
+      e(t);
   }
   emitStop() {
     for (const t of this.stopListeners)
       t();
   }
   emitError(t) {
-    for (const i of this.errorListeners)
-      i(t);
+    for (const e of this.errorListeners)
+      e(t);
   }
   async openWebsocket() {
     this.socket && await this.closeWebsocket();
@@ -1681,38 +1739,38 @@ class re {
       throw new Error("The WebSocket URL is not specified");
     this.socket = new WebSocket(t), this.socket.onopen = () => {
       this.socket && (this.connected = !0);
-    }, this.socket.binaryType = "arraybuffer", this.socket.onmessage = (i) => {
+    }, this.socket.binaryType = "arraybuffer", this.socket.onmessage = (e) => {
       try {
-        if (typeof i.data == "string")
+        if (typeof e.data == "string")
           return;
-        const e = new Uint8Array(i.data);
-        this.emitData(e);
+        const i = new Uint8Array(e.data);
+        this.emitData(i);
       } catch {
         this.connected = !1, this.emitStop();
       }
-    }, this.socket.onerror = (i) => {
+    }, this.socket.onerror = (e) => {
       this.connected = !1, this.emitError({
         code: 1006,
         // Standard «abnormal closure» code per RFC-6455
         message: "WebSocket error occurred",
-        raw: i
+        raw: e
       }), this.emitStop();
-    }, this.socket.onclose = async (i) => {
-      if (this.socket = null, this.connected = !1, i.code === C || k.has(i.code)) {
+    }, this.socket.onclose = async (e) => {
+      if (this.socket = null, this.connected = !1, e.code === U || I.has(e.code)) {
         this.emitError({
-          code: i.code,
-          message: i.reason,
-          raw: i
+          code: e.code,
+          message: e.reason,
+          raw: e
         });
         return;
       }
       this.emitStop();
     };
   }
-  sendInput({ keyName: t, value: i }) {
+  sendInput({ keyName: t, value: e }) {
     if (!this.socket || !this.connected)
       throw new Error("WebSocket: Not connected");
-    this.inputEvent[t] = i, this.socket.send(JSON.stringify(this.inputEvent)), i === 0 && delete this.inputEvent[t];
+    this.inputEvent[t] = e, this.socket.send(JSON.stringify(this.inputEvent)), e === 0 && delete this.inputEvent[t];
   }
   closeWebsocket() {
     return this.connected = !1, new Promise((t) => {
@@ -1722,9 +1780,437 @@ class re {
     });
   }
 }
+const m = class m {
+  constructor(t, e) {
+    u(this, "addr");
+    u(this, "token");
+    u(this, "isBinary");
+    u(this, "connectTimeout");
+    u(this, "dataTimeout");
+    u(this, "worker", null);
+    u(this, "connectionTimer", null);
+    u(this, "dataTimer", null);
+    u(this, "_status");
+    // Callbacks
+    u(this, "dataCallback");
+    u(this, "rawDataCallback");
+    u(this, "errorCallback");
+    u(this, "statusCallback");
+    this.addr = t.addr || "", this.token = t.token, this.isBinary = t.isBinary ?? !0, this.connectTimeout = (e == null ? void 0 : e.timeout) ?? 5e3, this.dataTimeout = (e == null ? void 0 : e.dataTimeout) ?? 15e3, this._status = {
+      main: { status: f.IDLE },
+      connection: { status: E.DISCONNECTED },
+      auth: { status: k.UNAUTHENTICATED },
+      data: { status: C.NONE },
+      worker: { status: S.OFF }
+    };
+  }
+  get status() {
+    return this._status;
+  }
+  /**
+   * Transforms http/https to ws/wss and prefixes with auto-inferred protocol if no protocol present.
+   */
+  resolveProtocol(t) {
+    let e = t.trim();
+    if (e.startsWith("https://"))
+      return e.replace("https://", "wss://");
+    if (e.startsWith("http://"))
+      return e.replace("http://", "ws://");
+    if (e.startsWith("wss://") || e.startsWith("ws://"))
+      return e;
+    let i = "ws:";
+    return typeof window < "u" && window.location.protocol === "https:" && (i = "wss:"), `${i}//${e}`;
+  }
+  /**
+   * Starts the stream connection.
+   * Throws an error if already running.
+   */
+  start({
+    dataCallback: t,
+    rawDataCallback: e,
+    errorCallback: i,
+    statusCallback: n
+  }) {
+    if (this._status.main.status === f.STARTING || this._status.main.status === f.RUNNING) {
+      const s = new y(d.STREAM_ALREADY_STARTED, "StateStream is already running. Call stop() before starting again.");
+      if (n && n({
+        ...this._status,
+        main: { ...this._status.main, lastError: s }
+      }), i)
+        i(s);
+      else
+        throw s;
+      return;
+    }
+    this.dataCallback = t, this.rawDataCallback = e, this.errorCallback = i, this.statusCallback = n, this.updateStatusComponent("main", { status: f.STARTING, lastError: void 0 });
+    try {
+      this.ensureWorker(), this.sendCommand({
+        type: "START",
+        addr: this.normalizeUrl(this.addr),
+        token: this.token,
+        isBinary: this.isBinary,
+        mode: this.streamMode
+      }), this.clearConnectionTimer(), this.connectionTimer = setTimeout(() => {
+        const s = new y(d.CONNECTION_TIMEOUT, `Connection timed out after ${this.connectTimeout}ms`);
+        this.mapErrorToStatus(s), this.errorCallback && this.errorCallback(s), this.stop();
+      }, this.connectTimeout);
+    } catch (s) {
+      const o = s instanceof y ? s : new y(d.UNKNOWN_ERROR, String(s));
+      this.errorCallback && this.errorCallback(o);
+    }
+  }
+  /**
+   * Stops the stream connection.
+   */
+  stop() {
+    this.clearConnectionTimer(), this.clearDataTimer(), !(this._status.main.status === f.IDLE || this._status.main.status === f.STOPPED) && (this.updateStatusComponent("main", { status: f.STOPPED }), this.updateStatusComponent("connection", { status: E.DISCONNECTED }), this.sendCommand({ type: "STOP" }), this.clearCallbacks());
+  }
+  /**
+   * Cleans up all resources.
+   */
+  destroy() {
+    this.stop(), this.worker && (this.worker.terminate ? this.worker.terminate() : "close" in this.worker.port && this.worker.port.close(), this.worker = null);
+  }
+  /**
+   * Clears all registered callbacks.
+   */
+  clearCallbacks() {
+    this.dataCallback = void 0, this.rawDataCallback = void 0, this.errorCallback = void 0, this.statusCallback = void 0;
+  }
+  /**
+   * Sends a new token to the worker (for auth or token refresh).
+   */
+  sendToken(t) {
+    this.token = t, this.sendCommand({ type: "UPDATE_TOKEN", token: t });
+  }
+  /**
+   * Sends a command to the worker port.
+   */
+  sendCommand(t) {
+    this.worker && this.worker.port.postMessage(t);
+  }
+  ensureWorker() {
+    if (this.worker || typeof window > "u") return;
+    const t = btoa(this.addr);
+    try {
+      this.updateStatusComponent("worker", { status: S.INITIALIZING, lastError: void 0 });
+      const e = new URL(
+        /* @vite-ignore */
+        "./index.worker.js",
+        import.meta.url
+      );
+      if (window.SharedWorker) {
+        const i = new SharedWorker(e, {
+          name: t,
+          type: "module"
+        });
+        this.worker = {
+          port: i.port
+        }, i.port.onmessage = (n) => {
+          this.handleWorkerMessage(n.data);
+        }, i.port.start();
+      } else {
+        const i = new Worker(e, { type: "module" });
+        this.worker = {
+          port: i,
+          terminate: () => i.terminate()
+        }, i.onmessage = (n) => {
+          this.handleWorkerMessage(n.data);
+        };
+      }
+      this.updateStatusComponent("worker", { status: S.READY });
+    } catch (e) {
+      const i = new y(d.WORKER_INIT_FAILED, `Failed to initialize worker: ${String(e)}`);
+      throw this.updateStatusComponent("worker", { status: S.ERROR, lastError: i }), this.updateStatusComponent("main", { status: f.FAILED, lastError: i }), i;
+    }
+  }
+  /**
+   * Processes messages from the worker.
+   */
+  handleWorkerMessage(t) {
+    switch (t.type) {
+      case "DATA":
+        this.resetDataTimer(), this.dataCallback && this.dataCallback(this.normalizeState(t.data));
+        break;
+      case "RAW_DATA":
+        this.resetDataTimer(), this.rawDataCallback && this.rawDataCallback(t.data);
+        break;
+      case "CONNECTED":
+        this.clearConnectionTimer(), this.updateStatusComponent("connection", { status: E.CONNECTED }), this.streamMode === "local" && this.updateStatusComponent("main", { status: f.RUNNING });
+        break;
+      case "STATUS_UPDATE":
+        t.connection && this.updateStatusComponent("connection", { status: t.connection }), t.auth && (this.updateStatusComponent("auth", { status: t.auth }), t.auth === k.AUTHENTICATED && this.updateStatusComponent("main", { status: f.RUNNING }));
+        break;
+      case "ERROR": {
+        this.clearConnectionTimer();
+        const e = new y(t.code, t.message, t.data);
+        this.mapErrorToStatus(e), this.errorCallback && this.errorCallback(e);
+        break;
+      }
+      case "TOKEN_EXPIRED":
+        this.updateStatusComponent("auth", { status: k.AUTHENTICATING }), this.handleTokenExpiredInternal();
+        break;
+      case "DISCONNECTED":
+        this.updateStatusComponent("connection", { status: E.DISCONNECTED });
+        break;
+    }
+  }
+  /**
+   * Maps an error code to the corresponding status component
+   */
+  mapErrorToStatus(t) {
+    const e = t.code;
+    (e === d.CONNECTION_FAILED || e === d.CONNECTION_LOST || e === d.RECONNECT_FAILED || e === d.CONNECTION_TIMEOUT) && (this.updateStatusComponent("connection", { status: E.DISCONNECTED, lastError: t }), this.updateStatusComponent("main", { status: f.FAILED, lastError: t })), (e === d.AUTH_FAILED || e === d.AUTH_REFRESH_FAILED) && (this.updateStatusComponent("auth", { status: k.FAILED, lastError: t }), this.updateStatusComponent("main", { status: f.FAILED, lastError: t })), (e === d.DEVICE_ERROR || e === d.DECODE_ERROR) && this.updateStatusComponent("main", { lastError: t });
+  }
+  /**
+   * Updates a single component of the status and notifies listeners
+   */
+  updateStatusComponent(t, e) {
+    const i = this._status[t];
+    this._status[t] = { ...i, ...e }, this.statusCallback && this.statusCallback({ ...this._status });
+  }
+  /**
+   * Safe timer cleanup
+   */
+  clearConnectionTimer() {
+    this.connectionTimer && (clearTimeout(this.connectionTimer), this.connectionTimer = null);
+  }
+  /**
+   * Reset the data inactivity timer
+   */
+  resetDataTimer() {
+    this.clearDataTimer(), this._status.data.status !== C.ACTIVE ? this.updateStatusComponent("data", {
+      status: C.ACTIVE,
+      lastActivity: Date.now()
+    }) : this._status.data.lastActivity = Date.now(), this.dataTimer = setTimeout(() => {
+      this.updateStatusComponent("data", { status: C.STALE });
+    }, this.dataTimeout);
+  }
+  clearDataTimer() {
+    this.dataTimer && (clearTimeout(this.dataTimer), this.dataTimer = null);
+  }
+  /**
+   * Normalizes the raw state from the worker into a ProcessedState for the UI.
+   * Extracts the 'state' key for each update and merges bar_id for remote mode.
+   */
+  normalizeState(t) {
+    let e, i;
+    "bar_id" in t && "state" in t ? (e = t.state, i = t.bar_id) : e = t;
+    let n = e.updates;
+    return n && (n = n.map((s) => {
+      const o = Object.keys(s).find((h) => s[h] != null);
+      return {
+        ...s,
+        state: o
+      };
+    })), {
+      ...e,
+      updates: n,
+      bar_id: i
+    };
+  }
+  /**
+   * Internally deduplicates token refresh requests for the same address.
+   */
+  async handleTokenExpiredInternal() {
+    const t = this.addr;
+    let e = m.tokenRefreshPromises.get(t);
+    if (!e && this.onTokenExpired && (e = (async () => {
+      try {
+        const n = this.onTokenExpired();
+        return n instanceof Promise ? await n : "";
+      } finally {
+        m.tokenRefreshPromises.delete(t);
+      }
+    })(), m.tokenRefreshPromises.set(t, e)), e) {
+      const i = await e;
+      i && this.sendToken(i);
+    }
+  }
+};
+/** Static map to deduplicate token refresh requests across all instances in this JS context */
+u(m, "tokenRefreshPromises", /* @__PURE__ */ new Map());
+let g = m;
+class Ee extends g {
+  constructor(e = {}, i) {
+    let n = e.addr;
+    n || (typeof window < "u" ? n = window.location.origin : n = "10.0.4.20");
+    super(
+      {
+        isBinary: !0,
+        // Default for local is binary
+        ...e,
+        addr: n
+      },
+      i
+    );
+    u(this, "streamMode", "local");
+  }
+  /**
+   * Normalizes the address to use ws:// protocol and adds default path if missing.
+   */
+  normalizeUrl(e) {
+    const i = this.resolveProtocol(e), n = new URL(i);
+    return (n.pathname === "/" || !n.pathname) && (n.pathname = "/api/status/ws"), n.toString();
+  }
+}
+class Se extends g {
+  constructor(e, i) {
+    super(
+      {
+        isBinary: !1,
+        // Default for remote is JSON
+        ...e
+      },
+      i
+    );
+    u(this, "streamMode", "remote");
+    u(this, "tokenProvider");
+    this.tokenProvider = e.tokenProvider;
+  }
+  /**
+   * Subscribes to updates for a specific device GUID.
+   */
+  subscribe(e) {
+    this.sendCommand({ type: "SUBSCRIBE", guid: e });
+  }
+  /**
+   * Unsubscribes from updates for a specific device GUID.
+   */
+  unsubscribe(e) {
+    this.sendCommand({ type: "UNSUBSCRIBE", guid: e });
+  }
+  /**
+   * Standardizes the address to use wss:// or ws:// protocol.
+   */
+  normalizeUrl(e) {
+    return this.resolveProtocol(e);
+  }
+  /**
+   * Handles token expiration by invoking the tokenProvider.
+   * Returns the promise for deduplication.
+   */
+  onTokenExpired() {
+    if (this.tokenProvider)
+      return this.tokenProvider().then((e) => (this.sendToken(e), e)).catch((e) => {
+        const i = `Failed to refresh token: ${e.message}`;
+        throw this.errorCallback && this.errorCallback(new y(d.AUTH_REFRESH_FAILED, i)), e;
+      });
+  }
+}
+const T = class T {
+  constructor() {
+    u(this, "gl", null);
+    u(this, "program", null);
+    u(this, "texture", null);
+    u(this, "vs", `#version 300 es
+    in vec2 position;
+    out vec2 v_uv;
+    void main() {
+      v_uv = position * 0.5 + 0.5;
+      v_uv.y = 1.0 - v_uv.y;
+      gl_Position = vec4(position, 0, 1);
+    }
+  `);
+    u(this, "fs", `#version 300 es
+    precision highp float;
+    in vec2 v_uv;
+    out vec4 outColor;
+    uniform sampler2D u_texture;
+    uniform vec2 u_dataRes;
+    uniform vec2 u_canvasRes;
+    uniform float u_pixelSize;
+    uniform float u_radius;
+    uniform float u_darkThreshold;
+    void main() {
+      vec2 gridPos = v_uv * u_dataRes;
+      vec2 localUv = fract(gridPos);
+      vec2 cellCoords = (floor(gridPos) + 0.5) / u_dataRes;
+      vec4 color = texture(u_texture, cellCoords);
+      if (dot(color.rgb, vec3(1.0)) < u_darkThreshold) discard;
+      float halfSize = u_pixelSize * 0.5;
+      float visualRadius = sqrt(clamp(u_radius, 0.0, 1.0));
+      float r = visualRadius * halfSize;
+      vec2 q = abs(localUv - 0.5) - (halfSize - r);
+      float dist = length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - r;
+      float unitsPerPixel = (u_dataRes.y / u_canvasRes.y);
+      float delta = unitsPerPixel * 1.5; 
+      float effectRes = (1.0 - u_pixelSize) + u_radius;
+      float effectStrength = smoothstep(0.0, 0.02, effectRes);
+      float edgeOffset = mix(0.0, -delta, effectStrength);
+      float mask = 1.0 - smoothstep(edgeOffset, edgeOffset + delta * 2.0, dist);
+      float vignette = smoothstep(0.7, 0.3, length(localUv - 0.5));
+      vec3 finalColor = color.rgb * (1.0 - (0.15 * effectStrength * (1.0 - vignette)));
+      if (mask < 0.001) discard;
+      outColor = vec4(finalColor, color.a * mask);
+    }
+  `);
+    if (T.instance)
+      return T.instance;
+    T.instance = this;
+  }
+  /**
+   * Lazily initializes the WebGL context and resources.
+   * Only executes in a browser environment.
+   */
+  init() {
+    if (this.gl || typeof window > "u")
+      return;
+    const e = document.createElement("canvas").getContext("webgl2", {
+      antialias: !0,
+      alpha: !0,
+      preserveDrawingBuffer: !0
+    });
+    if (!e)
+      throw new Error("WebGL 2.0 not supported");
+    this.gl = e, this.program = this.createProgram(this.vs, this.fs);
+    const i = e.createBuffer();
+    e.bindBuffer(e.ARRAY_BUFFER, i), e.bufferData(e.ARRAY_BUFFER, new Float32Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1]), e.STATIC_DRAW);
+    const n = e.getAttribLocation(this.program, "position");
+    e.enableVertexAttribArray(n), e.vertexAttribPointer(n, 2, e.FLOAT, !1, 0, 0), this.texture = e.createTexture(), e.bindTexture(e.TEXTURE_2D, this.texture), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE);
+  }
+  /**
+   * Internal WebGL rendering pass.
+   */
+  render(t, e, i, n) {
+    const { pixelSize: s = 0.85, radius: o = 0.5, darkThreshold: h = 0.04 } = n, c = this.gl;
+    c.viewport(0, 0, c.canvas.width, c.canvas.height), c.useProgram(this.program), c.bindTexture(c.TEXTURE_2D, this.texture), c.texImage2D(c.TEXTURE_2D, 0, c.RGBA8, e, i, 0, c.RGBA, c.UNSIGNED_BYTE, t), c.uniform2f(c.getUniformLocation(this.program, "u_dataRes"), e, i), c.uniform2f(c.getUniformLocation(this.program, "u_canvasRes"), c.canvas.width, c.canvas.height), c.uniform1f(c.getUniformLocation(this.program, "u_pixelSize"), s), c.uniform1f(c.getUniformLocation(this.program, "u_radius"), o), c.uniform1f(c.getUniformLocation(this.program, "u_darkThreshold"), h), c.clearColor(0, 0, 0, 0), c.clear(c.COLOR_BUFFER_BIT), c.enable(c.BLEND), c.blendFunc(c.SRC_ALPHA, c.ONE_MINUS_SRC_ALPHA), c.drawArrays(c.TRIANGLES, 0, 6);
+  }
+  /**
+   * Public API: Renders the LED frame to a target 2D canvas.
+   */
+  renderFrame(t, e, i, n, s = {}) {
+    if (this.init(), typeof window > "u" || !this.gl)
+      return;
+    (this.gl.canvas.width !== t.width || this.gl.canvas.height !== t.height) && (this.gl.canvas.width = t.width, this.gl.canvas.height = t.height), this.render(e, i, n, s);
+    const o = t.getContext("2d");
+    o && (o.clearRect(0, 0, t.width, t.height), o.drawImage(this.gl.canvas, 0, 0));
+  }
+  createProgram(t, e) {
+    const i = this.gl, n = (o, h) => {
+      const c = i.createShader(o);
+      if (i.shaderSource(c, h), i.compileShader(c), !i.getShaderParameter(c, i.COMPILE_STATUS)) throw new Error(i.getShaderInfoLog(c) || "Shader Error");
+      return c;
+    }, s = i.createProgram();
+    return i.attachShader(s, n(i.VERTEX_SHADER, t)), i.attachShader(s, n(i.FRAGMENT_SHADER, e)), i.linkProgram(s), s;
+  }
+};
+u(T, "instance", null);
+let R = T;
+const Ce = new R();
 export {
-  Yt as BusyBar,
-  p as DeviceScreen,
-  re as Input,
-  ne as ScreenStream
+  k as AuthStatus,
+  he as BusyBar,
+  E as ConnectionStatus,
+  C as DataStatus,
+  _ as DeviceScreen,
+  Te as Input,
+  Ce as LEDRenderer,
+  Ee as LocalStateStream,
+  Se as RemoteStateStream,
+  me as ScreenStream,
+  y as StateStreamError,
+  d as StateStreamErrorCode,
+  f as StreamLifecycle,
+  S as WorkerStatus
 };