@ikalogic/at1000 0.2.1 → 0.3.0

package/build/{power-BQGaOZjf.d.mts → power-DUs5Sw8n.d.mts}

@@ -1,5 +1,5 @@
 import { t as AnalogOutputLevel } from "./common-BY1vXz1l.mjs";
-import { l as Information } from "./management-C0iQha23.mjs";
+import { u as Information } from "./management-DliNzoq1.mjs";
 import { UpFetch } from "up-fetch";
 import * as v from "valibot";
 
@@ -16,7 +16,7 @@ declare const dutConfiguration: Omit<Omit<v.ObjectSchema<{
   readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly current: v.NumberSchema<undefined>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+}, undefined>, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: Pick<{
     readonly enabled: v.BooleanSchema<undefined>;
     readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
@@ -45,7 +45,7 @@ declare const dutConfiguration: Omit<Omit<v.ObjectSchema<{
     };
     readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
   } | undefined;
-}, "~types" | "~run" | "~standard" | "entries"> & {
+}, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: {
     readonly enabled: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     readonly target_voltage: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>, undefined>;
@@ -79,37 +79,37 @@ declare const usbState: Omit<v.ObjectSchema<{
   readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly current: v.NumberSchema<undefined>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+}, undefined>, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: Pick<{
     readonly enabled: v.BooleanSchema<undefined>;
     readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly current: v.NumberSchema<undefined>;
-  }, "enabled" | "current" | "voltage">;
+  }, "enabled" | "voltage" | "current">;
   readonly "~standard": v.StandardProps<{
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }, {
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }>;
   readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>>;
   readonly "~types"?: {
     readonly input: {
       enabled: boolean;
-      current: number;
       voltage: number;
+      current: number;
     };
     readonly output: {
       enabled: boolean;
-      current: number;
       voltage: number;
+      current: number;
     };
     readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
   } | undefined;
@@ -120,47 +120,47 @@ declare const usbConfiguration: Omit<Omit<v.ObjectSchema<{
   readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly current: v.NumberSchema<undefined>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+}, undefined>, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: Pick<{
     readonly enabled: v.BooleanSchema<undefined>;
     readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly current: v.NumberSchema<undefined>;
-  }, "enabled" | "current" | "voltage">;
+  }, "enabled" | "voltage" | "current">;
   readonly "~standard": v.StandardProps<{
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }, {
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }>;
   readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>>;
   readonly "~types"?: {
     readonly input: {
       enabled: boolean;
-      current: number;
       voltage: number;
+      current: number;
     };
     readonly output: {
       enabled: boolean;
-      current: number;
       voltage: number;
+      current: number;
     };
     readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
   } | undefined;
-}, "~types" | "~run" | "~standard" | "entries"> & {
+}, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: Pick<Pick<{
     readonly enabled: v.BooleanSchema<undefined>;
     readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly current: v.NumberSchema<undefined>;
-  }, "enabled" | "current" | "voltage">, "enabled">;
+  }, "enabled" | "voltage" | "current">, "enabled">;
   readonly "~standard": v.StandardProps<{
     enabled: boolean;
   }, {
@@ -185,7 +185,7 @@ declare const relayState: Omit<v.ObjectSchema<{
   readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly current: v.NumberSchema<undefined>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+}, undefined>, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: Pick<{
     readonly enabled: v.BooleanSchema<undefined>;
     readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
@@ -339,5 +339,5 @@ declare class RelayPower {
   read_current(): Promise<number>;
 }
 //#endregion
-export { RelayPower as a, UsbConfiguration as c, PowerApi as i, UsbState as l, DutConfiguration as n, RelayState as o, DutState as r, Usb as s, Dut as t };
-//# sourceMappingURL=power-BQGaOZjf.d.mts.map
+export { RelayPower as a, UsbConfiguration as c, usbState as d, PowerApi as i, UsbState as l, DutConfiguration as n, RelayState as o, DutState as r, Usb as s, Dut as t, dutState as u };
+//# sourceMappingURL=power-DUs5Sw8n.d.mts.map

package/build/{power-BQGaOZjf.d.mts.map → power-DUs5Sw8n.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"power-BQGaOZjf.d.mts","names":[],"sources":["../src/api/power.ts"],"mappings":";;;;;;cAQM,QAAA,EAAQ,CAAA,CAAA,YAAA;EAAA;;;;;KAMF,QAAA,GAAW,CAAA,CAAE,WAAW,QAAQ,QAAA;AAAA,cAEtC,gBAAA,EAAgB,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACV,gBAAA,GAAmB,CAAA,CAAE,WAAW,QAAQ,gBAAA;AAAA,cAE9C,QAAA,EAAQ,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACF,QAAA,GAAW,CAAA,CAAE,WAAW,QAAQ,QAAA;AAAA,cAEtC,gBAAA,EAAgB,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACV,gBAAA,GAAmB,CAAA,CAAE,WAAW,QAAQ,gBAAA;AAAA,cAE9C,UAAA,EAAU,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACJ,UAAA,GAAa,CAAA,CAAE,WAAW,QAAQ,UAAA;;cAGjC,QAAA;EAAA,iBAIkB,KAAA;EAAA,iBAHZ,SAAA;EAAA,iBACA,SAAA;cAEY,KAAA,EAAO,OAAA,EAAS,IAAA,EAAM,WAAA;;;;EAOnD,KAAA,IAAS,OAAA;;;;;;EAST,GAAA,CAAI,EAAA,WAAa,GAAA;;;;;;EAiBjB,GAAA,CAAI,EAAA,WAAa,GAAA;;;;;EAgBjB,OAAA,IAAW,UAAA;AAAA;;cAMA,GAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;EAK7D,KAAA,IAAS,OAAA;;;;;;EAST,SAAA,CAAU,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,QAAA;;;;;;EAa7C,MAAA,CAAO,OAAA,EAAS,iBAAA,GAAoB,OAAA,CAAQ,QAAA;;;;;EAQ5C,OAAA,IAAW,OAAA,CAAQ,QAAA;;;;;EAQnB,IAAA,IAAQ,OAAA,CAAQ,QAAA;;;;;EAQV,YAAA,IAAgB,OAAA;;;;;EAQhB,YAAA,IAAgB,OAAA;AAAA;;cAMX,GAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;EAK7D,KAAA,IAAS,OAAA;;;;AA/IX;;EAwJE,SAAA,CAAU,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,QAAA;EAxJH;;;;EAoK1C,MAAA,IAAU,OAAA,CAAQ,QAAA;EApKgD;AAAE;;;EA4KpE,OAAA,IAAW,OAAA,CAAQ,QAAA;;;;;EAQnB,IAAA,IAAQ,OAAA,CAAQ,QAAA;;;;;EAQV,YAAA,IAAgB,OAAA;EA1LV;;;;EAkMN,YAAA,IAAgB,OAAA;AAAA;;cAMX,UAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;;EAM7D,IAAA,IAAQ,OAAA,CAAQ,UAAA;;;;;EAQV,YAAA,IAAgB,OAAA;AAAA"}
+{"version":3,"file":"power-DUs5Sw8n.d.mts","names":[],"sources":["../src/api/power.ts"],"mappings":";;;;;;cAQa,QAAA,EAAQ,CAAA,CAAA,YAAA;EAAA;;;;;KAMT,QAAA,GAAW,CAAA,CAAE,WAAW,QAAQ,QAAA;AAAA,cAEtC,gBAAA,EAAgB,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACV,gBAAA,GAAmB,CAAA,CAAE,WAAW,QAAQ,gBAAA;AAAA,cAEvC,QAAA,EAAQ,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACT,QAAA,GAAW,CAAA,CAAE,WAAW,QAAQ,QAAA;AAAA,cAEtC,gBAAA,EAAgB,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACV,gBAAA,GAAmB,CAAA,CAAE,WAAW,QAAQ,gBAAA;AAAA,cAE9C,UAAA,EAAU,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACJ,UAAA,GAAa,CAAA,CAAE,WAAW,QAAQ,UAAA;;cAGjC,QAAA;EAAA,iBAIkB,KAAA;EAAA,iBAHZ,SAAA;EAAA,iBACA,SAAA;cAEY,KAAA,EAAO,OAAA,EAAS,IAAA,EAAM,WAAA;;;;EAOnD,KAAA,IAAS,OAAA;;;;;;EAST,GAAA,CAAI,EAAA,WAAa,GAAA;;;;;;EAiBjB,GAAA,CAAI,EAAA,WAAa,GAAA;;;;;EAgBjB,OAAA,IAAW,UAAA;AAAA;;cAMA,GAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;EAK7D,KAAA,IAAS,OAAA;;;;;;EAST,SAAA,CAAU,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,QAAA;;;;;;EAa7C,MAAA,CAAO,OAAA,EAAS,iBAAA,GAAoB,OAAA,CAAQ,QAAA;;;;;EAQ5C,OAAA,IAAW,OAAA,CAAQ,QAAA;;;;;EAQnB,IAAA,IAAQ,OAAA,CAAQ,QAAA;;;;;EAQV,YAAA,IAAgB,OAAA;;;;;EAQhB,YAAA,IAAgB,OAAA;AAAA;;cAMX,GAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;EAK7D,KAAA,IAAS,OAAA;;;;AA/IX;;EAwJE,SAAA,CAAU,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,QAAA;EAxJH;;;;EAoK1C,MAAA,IAAU,OAAA,CAAQ,QAAA;EApKgD;AAEpE;;;EA0KE,OAAA,IAAW,OAAA,CAAQ,QAAA;;;;;EAQnB,IAAA,IAAQ,OAAA,CAAQ,QAAA;;;;;EAQV,YAAA,IAAgB,OAAA;EA1LH;;;;EAkMb,YAAA,IAAgB,OAAA;AAAA;;cAMX,UAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;;EAM7D,IAAA,IAAQ,OAAA,CAAQ,UAAA;;;;;EAQV,YAAA,IAAgB,OAAA;AAAA"}

package/build/{power-CR0Hkay6.d.cts → power-zT64Y-Q9.d.cts}

@@ -1,5 +1,5 @@
 import { t as AnalogOutputLevel } from "./common-BY1vXz1l.cjs";
-import { l as Information } from "./management-C0iQha23.cjs";
+import { u as Information } from "./management-DliNzoq1.cjs";
 import { UpFetch } from "up-fetch";
 import * as v from "valibot";
 
@@ -16,7 +16,7 @@ declare const dutConfiguration: Omit<Omit<v.ObjectSchema<{
   readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly current: v.NumberSchema<undefined>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+}, undefined>, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: Pick<{
     readonly enabled: v.BooleanSchema<undefined>;
     readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
@@ -45,7 +45,7 @@ declare const dutConfiguration: Omit<Omit<v.ObjectSchema<{
     };
     readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
   } | undefined;
-}, "~types" | "~run" | "~standard" | "entries"> & {
+}, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: {
     readonly enabled: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     readonly target_voltage: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>, undefined>;
@@ -79,37 +79,37 @@ declare const usbState: Omit<v.ObjectSchema<{
   readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly current: v.NumberSchema<undefined>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+}, undefined>, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: Pick<{
     readonly enabled: v.BooleanSchema<undefined>;
     readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly current: v.NumberSchema<undefined>;
-  }, "enabled" | "current" | "voltage">;
+  }, "enabled" | "voltage" | "current">;
   readonly "~standard": v.StandardProps<{
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }, {
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }>;
   readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>>;
   readonly "~types"?: {
     readonly input: {
       enabled: boolean;
-      current: number;
       voltage: number;
+      current: number;
     };
     readonly output: {
       enabled: boolean;
-      current: number;
       voltage: number;
+      current: number;
     };
     readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
   } | undefined;
@@ -120,47 +120,47 @@ declare const usbConfiguration: Omit<Omit<v.ObjectSchema<{
   readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly current: v.NumberSchema<undefined>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+}, undefined>, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: Pick<{
     readonly enabled: v.BooleanSchema<undefined>;
     readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly current: v.NumberSchema<undefined>;
-  }, "enabled" | "current" | "voltage">;
+  }, "enabled" | "voltage" | "current">;
   readonly "~standard": v.StandardProps<{
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }, {
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }>;
   readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
     enabled: boolean;
-    current: number;
     voltage: number;
+    current: number;
   }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>>;
   readonly "~types"?: {
     readonly input: {
       enabled: boolean;
-      current: number;
       voltage: number;
+      current: number;
     };
     readonly output: {
       enabled: boolean;
-      current: number;
       voltage: number;
+      current: number;
     };
     readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
   } | undefined;
-}, "~types" | "~run" | "~standard" | "entries"> & {
+}, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: Pick<Pick<{
     readonly enabled: v.BooleanSchema<undefined>;
     readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
     readonly current: v.NumberSchema<undefined>;
-  }, "enabled" | "current" | "voltage">, "enabled">;
+  }, "enabled" | "voltage" | "current">, "enabled">;
   readonly "~standard": v.StandardProps<{
     enabled: boolean;
   }, {
@@ -185,7 +185,7 @@ declare const relayState: Omit<v.ObjectSchema<{
   readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
   readonly current: v.NumberSchema<undefined>;
-}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+}, undefined>, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: Pick<{
     readonly enabled: v.BooleanSchema<undefined>;
     readonly target_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
@@ -339,5 +339,5 @@ declare class RelayPower {
   read_current(): Promise<number>;
 }
 //#endregion
-export { RelayPower as a, UsbConfiguration as c, PowerApi as i, UsbState as l, DutConfiguration as n, RelayState as o, DutState as r, Usb as s, Dut as t };
-//# sourceMappingURL=power-CR0Hkay6.d.cts.map
+export { RelayPower as a, UsbConfiguration as c, usbState as d, PowerApi as i, UsbState as l, DutConfiguration as n, RelayState as o, DutState as r, Usb as s, Dut as t, dutState as u };
+//# sourceMappingURL=power-zT64Y-Q9.d.cts.map

package/build/{power-CR0Hkay6.d.cts.map → power-zT64Y-Q9.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"power-CR0Hkay6.d.cts","names":[],"sources":["../src/api/power.ts"],"mappings":";;;;;;cAQM,QAAA,EAAQ,CAAA,CAAA,YAAA;EAAA;;;;;KAMF,QAAA,GAAW,CAAA,CAAE,WAAW,QAAQ,QAAA;AAAA,cAEtC,gBAAA,EAAgB,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACV,gBAAA,GAAmB,CAAA,CAAE,WAAW,QAAQ,gBAAA;AAAA,cAE9C,QAAA,EAAQ,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACF,QAAA,GAAW,CAAA,CAAE,WAAW,QAAQ,QAAA;AAAA,cAEtC,gBAAA,EAAgB,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACV,gBAAA,GAAmB,CAAA,CAAE,WAAW,QAAQ,gBAAA;AAAA,cAE9C,UAAA,EAAU,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACJ,UAAA,GAAa,CAAA,CAAE,WAAW,QAAQ,UAAA;;cAGjC,QAAA;EAAA,iBAIkB,KAAA;EAAA,iBAHZ,SAAA;EAAA,iBACA,SAAA;cAEY,KAAA,EAAO,OAAA,EAAS,IAAA,EAAM,WAAA;;;;EAOnD,KAAA,IAAS,OAAA;;;;;;EAST,GAAA,CAAI,EAAA,WAAa,GAAA;;;;;;EAiBjB,GAAA,CAAI,EAAA,WAAa,GAAA;;;;;EAgBjB,OAAA,IAAW,UAAA;AAAA;;cAMA,GAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;EAK7D,KAAA,IAAS,OAAA;;;;;;EAST,SAAA,CAAU,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,QAAA;;;;;;EAa7C,MAAA,CAAO,OAAA,EAAS,iBAAA,GAAoB,OAAA,CAAQ,QAAA;;;;;EAQ5C,OAAA,IAAW,OAAA,CAAQ,QAAA;;;;;EAQnB,IAAA,IAAQ,OAAA,CAAQ,QAAA;;;;;EAQV,YAAA,IAAgB,OAAA;;;;;EAQhB,YAAA,IAAgB,OAAA;AAAA;;cAMX,GAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;EAK7D,KAAA,IAAS,OAAA;;;;AA/IX;;EAwJE,SAAA,CAAU,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,QAAA;EAxJH;;;;EAoK1C,MAAA,IAAU,OAAA,CAAQ,QAAA;EApKgD;AAAE;;;EA4KpE,OAAA,IAAW,OAAA,CAAQ,QAAA;;;;;EAQnB,IAAA,IAAQ,OAAA,CAAQ,QAAA;;;;;EAQV,YAAA,IAAgB,OAAA;EA1LV;;;;EAkMN,YAAA,IAAgB,OAAA;AAAA;;cAMX,UAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;;EAM7D,IAAA,IAAQ,OAAA,CAAQ,UAAA;;;;;EAQV,YAAA,IAAgB,OAAA;AAAA"}
+{"version":3,"file":"power-zT64Y-Q9.d.cts","names":[],"sources":["../src/api/power.ts"],"mappings":";;;;;;cAQa,QAAA,EAAQ,CAAA,CAAA,YAAA;EAAA;;;;;KAMT,QAAA,GAAW,CAAA,CAAE,WAAW,QAAQ,QAAA;AAAA,cAEtC,gBAAA,EAAgB,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACV,gBAAA,GAAmB,CAAA,CAAE,WAAW,QAAQ,gBAAA;AAAA,cAEvC,QAAA,EAAQ,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACT,QAAA,GAAW,CAAA,CAAE,WAAW,QAAQ,QAAA;AAAA,cAEtC,gBAAA,EAAgB,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACV,gBAAA,GAAmB,CAAA,CAAE,WAAW,QAAQ,gBAAA;AAAA,cAE9C,UAAA,EAAU,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACJ,UAAA,GAAa,CAAA,CAAE,WAAW,QAAQ,UAAA;;cAGjC,QAAA;EAAA,iBAIkB,KAAA;EAAA,iBAHZ,SAAA;EAAA,iBACA,SAAA;cAEY,KAAA,EAAO,OAAA,EAAS,IAAA,EAAM,WAAA;;;;EAOnD,KAAA,IAAS,OAAA;;;;;;EAST,GAAA,CAAI,EAAA,WAAa,GAAA;;;;;;EAiBjB,GAAA,CAAI,EAAA,WAAa,GAAA;;;;;EAgBjB,OAAA,IAAW,UAAA;AAAA;;cAMA,GAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;EAK7D,KAAA,IAAS,OAAA;;;;;;EAST,SAAA,CAAU,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,QAAA;;;;;;EAa7C,MAAA,CAAO,OAAA,EAAS,iBAAA,GAAoB,OAAA,CAAQ,QAAA;;;;;EAQ5C,OAAA,IAAW,OAAA,CAAQ,QAAA;;;;;EAQnB,IAAA,IAAQ,OAAA,CAAQ,QAAA;;;;;EAQV,YAAA,IAAgB,OAAA;;;;;EAQhB,YAAA,IAAgB,OAAA;AAAA;;cAMX,GAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;EAK7D,KAAA,IAAS,OAAA;;;;AA/IX;;EAwJE,SAAA,CAAU,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,QAAA;EAxJH;;;;EAoK1C,MAAA,IAAU,OAAA,CAAQ,QAAA;EApKgD;AAEpE;;;EA0KE,OAAA,IAAW,OAAA,CAAQ,QAAA;;;;;EAQnB,IAAA,IAAQ,OAAA,CAAQ,QAAA;;;;;EAQV,YAAA,IAAgB,OAAA;EA1LH;;;;EAkMb,YAAA,IAAgB,OAAA;AAAA;;cAMX,UAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;;EAM7D,IAAA,IAAQ,OAAA,CAAQ,UAAA;;;;;EAQV,YAAA,IAAgB,OAAA;AAAA"}

package/build/power.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./chunk-CMqjfN_6.cjs"),t=require("./common-BSabSaAU.cjs");let n=require("valibot");n=e.t(n,1);const r=n.object({enabled:n.boolean(),target_voltage:t.t,voltage:t.t,current:n.number()}),i=n.partial(n.pick(r,[`enabled`,`target_voltage`])),a=n.pick(r,[`enabled`,`current`,`voltage`]),o=n.pick(a,[`enabled`]),s=n.pick(r,[`current`]);var c=class{fetch;usb_count;dut_count=1;constructor(e,t){this.fetch=e,this.usb_count=t.capabilities.usb_ports.reduce((e,t)=>e+t.count,0)}reset(){return this.fetch(`/power/reset`,{method:`POST`,parseResponse:()=>{}})}dut(e){if(e<0||e>=this.dut_count)throw Error(`Invalid DUT id ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a DUT ID between 0 and ${this.dut_count-1}\n    Path: /power/dut/${e}`);return new l(this.fetch,e)}usb(e){if(e<0||e>=this.usb_count)throw Error(`Invalid USB port ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a USB port ID between 0 and ${this.usb_count-1}\n    Path: /power/usb/${e}`);return new u(this.fetch,e)}relay_0(){return new d(this.fetch,0)}},l=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}reset(){return this.fetch(`/power/dut/${this.id}/reset`,{method:`POST`,parseResponse:()=>{}})}configure(e){return this.fetch(`/power/dut/${this.id}`,{method:`PATCH`,body:n.parse(i,e),schema:r})}enable(e){return this.configure({enabled:!0,target_voltage:e})}disable(){return this.configure({enabled:!1})}read(){return this.fetch(`/power/dut/${this.id}`,{schema:r})}async read_current(){return(await this.read()).current}async read_voltage(){return(await this.read()).voltage}},u=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}reset(){return this.fetch(`/power/usb/${this.id}/reset`,{method:`POST`,parseResponse:()=>{}})}configure(e){return this.fetch(`/power/usb/${this.id}`,{method:`PATCH`,body:n.parse(o,e),schema:a})}enable(){return this.configure({enabled:!0})}disable(){return this.configure({enabled:!1})}read(){return this.fetch(`/power/usb/${this.id}`,{schema:a})}async read_current(){return(await this.read()).current}async read_voltage(){return(await this.read()).voltage}},d=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}read(){return this.fetch(`/power/relay/${this.id}`,{schema:s})}async read_current(){return(await this.read()).current}};exports.Dut=l,exports.PowerApi=c,exports.RelayPower=d,exports.Usb=u;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./chunk-CMqjfN_6.cjs"),t=require("./common-BSabSaAU.cjs");let n=require("valibot");n=e.t(n,1);const r=n.object({enabled:n.boolean(),target_voltage:t.t,voltage:t.t,current:n.number()}),i=n.partial(n.pick(r,[`enabled`,`target_voltage`])),a=n.pick(r,[`enabled`,`current`,`voltage`]),o=n.pick(a,[`enabled`]),s=n.pick(r,[`current`]);var c=class{fetch;usb_count;dut_count=1;constructor(e,t){this.fetch=e,this.usb_count=t.capabilities.usb_ports.reduce((e,t)=>e+t.count,0)}reset(){return this.fetch(`/power/reset`,{method:`POST`,parseResponse:()=>{}})}dut(e){if(e<0||e>=this.dut_count)throw Error(`Invalid DUT id ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a DUT ID between 0 and ${this.dut_count-1}\n    Path: /power/dut/${e}`);return new l(this.fetch,e)}usb(e){if(e<0||e>=this.usb_count)throw Error(`Invalid USB port ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a USB port ID between 0 and ${this.usb_count-1}\n    Path: /power/usb/${e}`);return new u(this.fetch,e)}relay_0(){return new d(this.fetch,0)}},l=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}reset(){return this.fetch(`/power/dut/${this.id}/reset`,{method:`POST`,parseResponse:()=>{}})}configure(e){return this.fetch(`/power/dut/${this.id}`,{method:`PATCH`,body:n.parse(i,e),schema:r})}enable(e){return this.configure({enabled:!0,target_voltage:e})}disable(){return this.configure({enabled:!1})}read(){return this.fetch(`/power/dut/${this.id}`,{schema:r})}async read_current(){return(await this.read()).current}async read_voltage(){return(await this.read()).voltage}},u=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}reset(){return this.fetch(`/power/usb/${this.id}/reset`,{method:`POST`,parseResponse:()=>{}})}configure(e){return this.fetch(`/power/usb/${this.id}`,{method:`PATCH`,body:n.parse(o,e),schema:a})}enable(){return this.configure({enabled:!0})}disable(){return this.configure({enabled:!1})}read(){return this.fetch(`/power/usb/${this.id}`,{schema:a})}async read_current(){return(await this.read()).current}async read_voltage(){return(await this.read()).voltage}},d=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}read(){return this.fetch(`/power/relay/${this.id}`,{schema:s})}async read_current(){return(await this.read()).current}};exports.Dut=l,exports.PowerApi=c,exports.RelayPower=d,exports.Usb=u,exports.dutState=r,exports.usbState=a;
 //# sourceMappingURL=power.cjs.map

package/build/power.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"power.cjs","names":["v","analogLevel"],"sources":["../src/api/power.ts"],"sourcesContent":["import type { UpFetch } from 'up-fetch';\nimport * as v from 'valibot';\n\nimport { analogLevel, type AnalogOutputLevel } from './common';\nimport type { Information } from './management';\n\nexport type { AnalogOutputLevel };\n\nconst dutState = v.object({\n  enabled: v.boolean(),\n  target_voltage: analogLevel,\n  voltage: analogLevel,\n  current: v.number(),\n});\nexport type DutState = v.InferOutput<typeof dutState>;\n\nconst dutConfiguration = v.partial(v.pick(dutState, ['enabled', 'target_voltage']));\nexport type DutConfiguration = v.InferOutput<typeof dutConfiguration>;\n\nconst usbState = v.pick(dutState, ['enabled', 'current', 'voltage']);\nexport type UsbState = v.InferOutput<typeof usbState>;\n\nconst usbConfiguration = v.pick(usbState, ['enabled']);\nexport type UsbConfiguration = v.InferOutput<typeof usbConfiguration>;\n\nconst relayState = v.pick(dutState, ['current']);\nexport type RelayState = v.InferOutput<typeof relayState>;\n\n/** @hideconstructor */\nexport class PowerApi {\n  private readonly usb_count: number;\n  private readonly dut_count = 1;\n\n  constructor(private readonly fetch: UpFetch, info: Information) {\n    this.usb_count = info.capabilities.usb_ports.reduce((a, b) => a + b.count, 0);\n  }\n\n  /**\n   * Resets the power API.\n   */\n  reset(): Promise<void> {\n    return this.fetch('/power/reset', { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Access a specific DUT by id.\n   * @param id The DUT id.\n   * @returns The DUT instance.\n   */\n  dut(id: number): Dut {\n    if (id < 0 || id >= this.dut_count) {\n      throw new Error(\n        `Invalid DUT id ${id} (RESOURCE_NOT_FOUND)\\n    Suggestion: Use a DUT ID between 0 and ${\n          this.dut_count - 1\n        }\\n    Path: /power/dut/${id}`,\n      );\n    }\n\n    return new Dut(this.fetch, id);\n  }\n\n  /**\n   * Access a specific USB port by id.\n   * @param id The USB port id.\n   * @returns The USB port instance.\n   */\n  usb(id: number): Usb {\n    if (id < 0 || id >= this.usb_count) {\n      throw new Error(\n        `Invalid USB port ${id} (RESOURCE_NOT_FOUND)\\n    Suggestion: Use a USB port ID between 0 and ${\n          this.usb_count - 1\n        }\\n    Path: /power/usb/${id}`,\n      );\n    }\n\n    return new Usb(this.fetch, id);\n  }\n\n  /**\n   * Access the relay at index 0.\n   * @returns The relay instance.\n   */\n  relay_0(): RelayPower {\n    return new RelayPower(this.fetch, 0);\n  }\n}\n\n/** @hideconstructor */\nexport class Dut {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Resets the DUT.\n   */\n  reset(): Promise<void> {\n    return this.fetch(`/power/dut/${this.id}/reset`, { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Configures the DUT.\n   * @param config The configuration to apply.\n   * @returns The updated DUT state.\n   */\n  configure(config: DutConfiguration): Promise<DutState> {\n    return this.fetch(`/power/dut/${this.id}`, {\n      method: 'PATCH',\n      body: v.parse(dutConfiguration, config),\n      schema: dutState,\n    });\n  }\n\n  /**\n   * Enables the DUT power supply at the specified voltage.\n   * @param voltage The target voltage to set.\n   * @returns The updated DUT state.\n   */\n  enable(voltage: AnalogOutputLevel): Promise<DutState> {\n    return this.configure({ enabled: true, target_voltage: voltage });\n  }\n\n  /**\n   * Disables the DUT power supply.\n   * @returns The updated DUT state.\n   */\n  disable(): Promise<DutState> {\n    return this.configure({ enabled: false });\n  }\n\n  /**\n   * Reads the current DUT state.\n   * @returns The current DUT state.\n   */\n  read(): Promise<DutState> {\n    return this.fetch(`/power/dut/${this.id}`, { schema: dutState });\n  }\n\n  /**\n   * Reads the current drawn by the DUT.\n   * @returns The current drawn by the DUT.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n\n  /**\n   * Reads the voltage supplied to the DUT.\n   * @returns The voltage supplied to the DUT.\n   */\n  async read_voltage(): Promise<number> {\n    return (await this.read()).voltage;\n  }\n}\n\n/** @hideconstructor */\nexport class Usb {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Resets the USB port.\n   */\n  reset(): Promise<void> {\n    return this.fetch(`/power/usb/${this.id}/reset`, { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Configures the USB port.\n   * @param config The configuration to apply.\n   * @returns The updated USB state.\n   */\n  configure(config: UsbConfiguration): Promise<UsbState> {\n    return this.fetch(`/power/usb/${this.id}`, {\n      method: 'PATCH',\n      body: v.parse(usbConfiguration, config),\n      schema: usbState,\n    });\n  }\n\n  /**\n   * Enables the USB port power.\n   * @returns The updated USB state.\n   */\n  enable(): Promise<UsbState> {\n    return this.configure({ enabled: true });\n  }\n\n  /**\n   * Disables the USB port power.\n   * @returns The updated USB state.\n   */\n  disable(): Promise<UsbState> {\n    return this.configure({ enabled: false });\n  }\n\n  /**\n   * Reads the current state of the USB port.\n   * @returns The current USB state.\n   */\n  read(): Promise<UsbState> {\n    return this.fetch(`/power/usb/${this.id}`, { schema: usbState });\n  }\n\n  /**\n   * Reads the current drawn by the USB port.\n   * @returns The current drawn by the USB port.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n\n  /**\n   * Reads the voltage at the USB port.\n   * @returns The voltage at the USB port.\n   */\n  async read_voltage(): Promise<number> {\n    return (await this.read()).voltage;\n  }\n}\n\n/** @hideconstructor */\nexport class RelayPower {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Reads the current state of the relay.\n   * @returns The current relay state.\n   */\n  read(): Promise<RelayState> {\n    return this.fetch(`/power/relay/${this.id}`, { schema: relayState });\n  }\n\n  /**\n   * Reads the current drawn through the relay.\n   * @returns The current drawn through the relay.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"power.cjs","names":["v","analogLevel"],"sources":["../src/api/power.ts"],"sourcesContent":["import type { UpFetch } from 'up-fetch';\nimport * as v from 'valibot';\n\nimport { analogLevel, type AnalogOutputLevel } from './common';\nimport type { Information } from './management';\n\nexport type { AnalogOutputLevel };\n\nexport const dutState = v.object({\n  enabled: v.boolean(),\n  target_voltage: analogLevel,\n  voltage: analogLevel,\n  current: v.number(),\n});\nexport type DutState = v.InferOutput<typeof dutState>;\n\nconst dutConfiguration = v.partial(v.pick(dutState, ['enabled', 'target_voltage']));\nexport type DutConfiguration = v.InferOutput<typeof dutConfiguration>;\n\nexport const usbState = v.pick(dutState, ['enabled', 'current', 'voltage']);\nexport type UsbState = v.InferOutput<typeof usbState>;\n\nconst usbConfiguration = v.pick(usbState, ['enabled']);\nexport type UsbConfiguration = v.InferOutput<typeof usbConfiguration>;\n\nconst relayState = v.pick(dutState, ['current']);\nexport type RelayState = v.InferOutput<typeof relayState>;\n\n/** @hideconstructor */\nexport class PowerApi {\n  private readonly usb_count: number;\n  private readonly dut_count = 1;\n\n  constructor(private readonly fetch: UpFetch, info: Information) {\n    this.usb_count = info.capabilities.usb_ports.reduce((a, b) => a + b.count, 0);\n  }\n\n  /**\n   * Resets the power API.\n   */\n  reset(): Promise<void> {\n    return this.fetch('/power/reset', { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Access a specific DUT by id.\n   * @param id The DUT id.\n   * @returns The DUT instance.\n   */\n  dut(id: number): Dut {\n    if (id < 0 || id >= this.dut_count) {\n      throw new Error(\n        `Invalid DUT id ${id} (RESOURCE_NOT_FOUND)\\n    Suggestion: Use a DUT ID between 0 and ${\n          this.dut_count - 1\n        }\\n    Path: /power/dut/${id}`,\n      );\n    }\n\n    return new Dut(this.fetch, id);\n  }\n\n  /**\n   * Access a specific USB port by id.\n   * @param id The USB port id.\n   * @returns The USB port instance.\n   */\n  usb(id: number): Usb {\n    if (id < 0 || id >= this.usb_count) {\n      throw new Error(\n        `Invalid USB port ${id} (RESOURCE_NOT_FOUND)\\n    Suggestion: Use a USB port ID between 0 and ${\n          this.usb_count - 1\n        }\\n    Path: /power/usb/${id}`,\n      );\n    }\n\n    return new Usb(this.fetch, id);\n  }\n\n  /**\n   * Access the relay at index 0.\n   * @returns The relay instance.\n   */\n  relay_0(): RelayPower {\n    return new RelayPower(this.fetch, 0);\n  }\n}\n\n/** @hideconstructor */\nexport class Dut {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Resets the DUT.\n   */\n  reset(): Promise<void> {\n    return this.fetch(`/power/dut/${this.id}/reset`, { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Configures the DUT.\n   * @param config The configuration to apply.\n   * @returns The updated DUT state.\n   */\n  configure(config: DutConfiguration): Promise<DutState> {\n    return this.fetch(`/power/dut/${this.id}`, {\n      method: 'PATCH',\n      body: v.parse(dutConfiguration, config),\n      schema: dutState,\n    });\n  }\n\n  /**\n   * Enables the DUT power supply at the specified voltage.\n   * @param voltage The target voltage to set.\n   * @returns The updated DUT state.\n   */\n  enable(voltage: AnalogOutputLevel): Promise<DutState> {\n    return this.configure({ enabled: true, target_voltage: voltage });\n  }\n\n  /**\n   * Disables the DUT power supply.\n   * @returns The updated DUT state.\n   */\n  disable(): Promise<DutState> {\n    return this.configure({ enabled: false });\n  }\n\n  /**\n   * Reads the current DUT state.\n   * @returns The current DUT state.\n   */\n  read(): Promise<DutState> {\n    return this.fetch(`/power/dut/${this.id}`, { schema: dutState });\n  }\n\n  /**\n   * Reads the current drawn by the DUT.\n   * @returns The current drawn by the DUT.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n\n  /**\n   * Reads the voltage supplied to the DUT.\n   * @returns The voltage supplied to the DUT.\n   */\n  async read_voltage(): Promise<number> {\n    return (await this.read()).voltage;\n  }\n}\n\n/** @hideconstructor */\nexport class Usb {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Resets the USB port.\n   */\n  reset(): Promise<void> {\n    return this.fetch(`/power/usb/${this.id}/reset`, { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Configures the USB port.\n   * @param config The configuration to apply.\n   * @returns The updated USB state.\n   */\n  configure(config: UsbConfiguration): Promise<UsbState> {\n    return this.fetch(`/power/usb/${this.id}`, {\n      method: 'PATCH',\n      body: v.parse(usbConfiguration, config),\n      schema: usbState,\n    });\n  }\n\n  /**\n   * Enables the USB port power.\n   * @returns The updated USB state.\n   */\n  enable(): Promise<UsbState> {\n    return this.configure({ enabled: true });\n  }\n\n  /**\n   * Disables the USB port power.\n   * @returns The updated USB state.\n   */\n  disable(): Promise<UsbState> {\n    return this.configure({ enabled: false });\n  }\n\n  /**\n   * Reads the current state of the USB port.\n   * @returns The current USB state.\n   */\n  read(): Promise<UsbState> {\n    return this.fetch(`/power/usb/${this.id}`, { schema: usbState });\n  }\n\n  /**\n   * Reads the current drawn by the USB port.\n   * @returns The current drawn by the USB port.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n\n  /**\n   * Reads the voltage at the USB port.\n   * @returns The voltage at the USB port.\n   */\n  async read_voltage(): Promise<number> {\n    return (await this.read()).voltage;\n  }\n}\n\n/** @hideconstructor */\nexport class RelayPower {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Reads the current state of the relay.\n   * @returns The current relay state.\n   */\n  read(): Promise<RelayState> {\n    return this.fetch(`/power/relay/${this.id}`, { schema: relayState });\n  }\n\n  /**\n   * Reads the current drawn through the relay.\n   * @returns The current drawn through the relay.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n}\n"],"mappings":"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"}

package/build/power.d.cts

@@ -1,3 +1,3 @@
 import { t as AnalogOutputLevel } from "./common-BY1vXz1l.cjs";
-import { a as RelayPower, c as UsbConfiguration, i as PowerApi, l as UsbState, n as DutConfiguration, o as RelayState, r as DutState, s as Usb, t as Dut } from "./power-CR0Hkay6.cjs";
-export { type AnalogOutputLevel, Dut, DutConfiguration, DutState, PowerApi, RelayPower, RelayState, Usb, UsbConfiguration, UsbState };
+import { a as RelayPower, c as UsbConfiguration, d as usbState, i as PowerApi, l as UsbState, n as DutConfiguration, o as RelayState, r as DutState, s as Usb, t as Dut, u as dutState } from "./power-zT64Y-Q9.cjs";
+export { type AnalogOutputLevel, Dut, DutConfiguration, DutState, PowerApi, RelayPower, RelayState, Usb, UsbConfiguration, UsbState, dutState, usbState };

package/build/power.d.mts

@@ -1,3 +1,3 @@
 import { t as AnalogOutputLevel } from "./common-BY1vXz1l.mjs";
-import { a as RelayPower, c as UsbConfiguration, i as PowerApi, l as UsbState, n as DutConfiguration, o as RelayState, r as DutState, s as Usb, t as Dut } from "./power-BQGaOZjf.mjs";
-export { type AnalogOutputLevel, Dut, DutConfiguration, DutState, PowerApi, RelayPower, RelayState, Usb, UsbConfiguration, UsbState };
+import { a as RelayPower, c as UsbConfiguration, d as usbState, i as PowerApi, l as UsbState, n as DutConfiguration, o as RelayState, r as DutState, s as Usb, t as Dut, u as dutState } from "./power-DUs5Sw8n.mjs";
+export { type AnalogOutputLevel, Dut, DutConfiguration, DutState, PowerApi, RelayPower, RelayState, Usb, UsbConfiguration, UsbState, dutState, usbState };

package/build/power.mjs

@@ -1,2 +1,2 @@
-import{t as e}from"./common-Ce3FeF-Q.mjs";import*as t from"valibot";const n=t.object({enabled:t.boolean(),target_voltage:e,voltage:e,current:t.number()}),r=t.partial(t.pick(n,[`enabled`,`target_voltage`])),i=t.pick(n,[`enabled`,`current`,`voltage`]),a=t.pick(i,[`enabled`]),o=t.pick(n,[`current`]);var s=class{fetch;usb_count;dut_count=1;constructor(e,t){this.fetch=e,this.usb_count=t.capabilities.usb_ports.reduce((e,t)=>e+t.count,0)}reset(){return this.fetch(`/power/reset`,{method:`POST`,parseResponse:()=>{}})}dut(e){if(e<0||e>=this.dut_count)throw Error(`Invalid DUT id ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a DUT ID between 0 and ${this.dut_count-1}\n    Path: /power/dut/${e}`);return new c(this.fetch,e)}usb(e){if(e<0||e>=this.usb_count)throw Error(`Invalid USB port ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a USB port ID between 0 and ${this.usb_count-1}\n    Path: /power/usb/${e}`);return new l(this.fetch,e)}relay_0(){return new u(this.fetch,0)}},c=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}reset(){return this.fetch(`/power/dut/${this.id}/reset`,{method:`POST`,parseResponse:()=>{}})}configure(e){return this.fetch(`/power/dut/${this.id}`,{method:`PATCH`,body:t.parse(r,e),schema:n})}enable(e){return this.configure({enabled:!0,target_voltage:e})}disable(){return this.configure({enabled:!1})}read(){return this.fetch(`/power/dut/${this.id}`,{schema:n})}async read_current(){return(await this.read()).current}async read_voltage(){return(await this.read()).voltage}},l=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}reset(){return this.fetch(`/power/usb/${this.id}/reset`,{method:`POST`,parseResponse:()=>{}})}configure(e){return this.fetch(`/power/usb/${this.id}`,{method:`PATCH`,body:t.parse(a,e),schema:i})}enable(){return this.configure({enabled:!0})}disable(){return this.configure({enabled:!1})}read(){return this.fetch(`/power/usb/${this.id}`,{schema:i})}async read_current(){return(await this.read()).current}async read_voltage(){return(await this.read()).voltage}},u=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}read(){return this.fetch(`/power/relay/${this.id}`,{schema:o})}async read_current(){return(await this.read()).current}};export{c as Dut,s as PowerApi,u as RelayPower,l as Usb};
+import{t as e}from"./common-Ce3FeF-Q.mjs";import*as t from"valibot";const n=t.object({enabled:t.boolean(),target_voltage:e,voltage:e,current:t.number()}),r=t.partial(t.pick(n,[`enabled`,`target_voltage`])),i=t.pick(n,[`enabled`,`current`,`voltage`]),a=t.pick(i,[`enabled`]),o=t.pick(n,[`current`]);var s=class{fetch;usb_count;dut_count=1;constructor(e,t){this.fetch=e,this.usb_count=t.capabilities.usb_ports.reduce((e,t)=>e+t.count,0)}reset(){return this.fetch(`/power/reset`,{method:`POST`,parseResponse:()=>{}})}dut(e){if(e<0||e>=this.dut_count)throw Error(`Invalid DUT id ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a DUT ID between 0 and ${this.dut_count-1}\n    Path: /power/dut/${e}`);return new c(this.fetch,e)}usb(e){if(e<0||e>=this.usb_count)throw Error(`Invalid USB port ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a USB port ID between 0 and ${this.usb_count-1}\n    Path: /power/usb/${e}`);return new l(this.fetch,e)}relay_0(){return new u(this.fetch,0)}},c=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}reset(){return this.fetch(`/power/dut/${this.id}/reset`,{method:`POST`,parseResponse:()=>{}})}configure(e){return this.fetch(`/power/dut/${this.id}`,{method:`PATCH`,body:t.parse(r,e),schema:n})}enable(e){return this.configure({enabled:!0,target_voltage:e})}disable(){return this.configure({enabled:!1})}read(){return this.fetch(`/power/dut/${this.id}`,{schema:n})}async read_current(){return(await this.read()).current}async read_voltage(){return(await this.read()).voltage}},l=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}reset(){return this.fetch(`/power/usb/${this.id}/reset`,{method:`POST`,parseResponse:()=>{}})}configure(e){return this.fetch(`/power/usb/${this.id}`,{method:`PATCH`,body:t.parse(a,e),schema:i})}enable(){return this.configure({enabled:!0})}disable(){return this.configure({enabled:!1})}read(){return this.fetch(`/power/usb/${this.id}`,{schema:i})}async read_current(){return(await this.read()).current}async read_voltage(){return(await this.read()).voltage}},u=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}read(){return this.fetch(`/power/relay/${this.id}`,{schema:o})}async read_current(){return(await this.read()).current}};export{c as Dut,s as PowerApi,u as RelayPower,l as Usb,n as dutState,i as usbState};
 //# sourceMappingURL=power.mjs.map

package/build/power.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"power.mjs","names":[],"sources":["../src/api/power.ts"],"sourcesContent":["import type { UpFetch } from 'up-fetch';\nimport * as v from 'valibot';\n\nimport { analogLevel, type AnalogOutputLevel } from './common';\nimport type { Information } from './management';\n\nexport type { AnalogOutputLevel };\n\nconst dutState = v.object({\n  enabled: v.boolean(),\n  target_voltage: analogLevel,\n  voltage: analogLevel,\n  current: v.number(),\n});\nexport type DutState = v.InferOutput<typeof dutState>;\n\nconst dutConfiguration = v.partial(v.pick(dutState, ['enabled', 'target_voltage']));\nexport type DutConfiguration = v.InferOutput<typeof dutConfiguration>;\n\nconst usbState = v.pick(dutState, ['enabled', 'current', 'voltage']);\nexport type UsbState = v.InferOutput<typeof usbState>;\n\nconst usbConfiguration = v.pick(usbState, ['enabled']);\nexport type UsbConfiguration = v.InferOutput<typeof usbConfiguration>;\n\nconst relayState = v.pick(dutState, ['current']);\nexport type RelayState = v.InferOutput<typeof relayState>;\n\n/** @hideconstructor */\nexport class PowerApi {\n  private readonly usb_count: number;\n  private readonly dut_count = 1;\n\n  constructor(private readonly fetch: UpFetch, info: Information) {\n    this.usb_count = info.capabilities.usb_ports.reduce((a, b) => a + b.count, 0);\n  }\n\n  /**\n   * Resets the power API.\n   */\n  reset(): Promise<void> {\n    return this.fetch('/power/reset', { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Access a specific DUT by id.\n   * @param id The DUT id.\n   * @returns The DUT instance.\n   */\n  dut(id: number): Dut {\n    if (id < 0 || id >= this.dut_count) {\n      throw new Error(\n        `Invalid DUT id ${id} (RESOURCE_NOT_FOUND)\\n    Suggestion: Use a DUT ID between 0 and ${\n          this.dut_count - 1\n        }\\n    Path: /power/dut/${id}`,\n      );\n    }\n\n    return new Dut(this.fetch, id);\n  }\n\n  /**\n   * Access a specific USB port by id.\n   * @param id The USB port id.\n   * @returns The USB port instance.\n   */\n  usb(id: number): Usb {\n    if (id < 0 || id >= this.usb_count) {\n      throw new Error(\n        `Invalid USB port ${id} (RESOURCE_NOT_FOUND)\\n    Suggestion: Use a USB port ID between 0 and ${\n          this.usb_count - 1\n        }\\n    Path: /power/usb/${id}`,\n      );\n    }\n\n    return new Usb(this.fetch, id);\n  }\n\n  /**\n   * Access the relay at index 0.\n   * @returns The relay instance.\n   */\n  relay_0(): RelayPower {\n    return new RelayPower(this.fetch, 0);\n  }\n}\n\n/** @hideconstructor */\nexport class Dut {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Resets the DUT.\n   */\n  reset(): Promise<void> {\n    return this.fetch(`/power/dut/${this.id}/reset`, { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Configures the DUT.\n   * @param config The configuration to apply.\n   * @returns The updated DUT state.\n   */\n  configure(config: DutConfiguration): Promise<DutState> {\n    return this.fetch(`/power/dut/${this.id}`, {\n      method: 'PATCH',\n      body: v.parse(dutConfiguration, config),\n      schema: dutState,\n    });\n  }\n\n  /**\n   * Enables the DUT power supply at the specified voltage.\n   * @param voltage The target voltage to set.\n   * @returns The updated DUT state.\n   */\n  enable(voltage: AnalogOutputLevel): Promise<DutState> {\n    return this.configure({ enabled: true, target_voltage: voltage });\n  }\n\n  /**\n   * Disables the DUT power supply.\n   * @returns The updated DUT state.\n   */\n  disable(): Promise<DutState> {\n    return this.configure({ enabled: false });\n  }\n\n  /**\n   * Reads the current DUT state.\n   * @returns The current DUT state.\n   */\n  read(): Promise<DutState> {\n    return this.fetch(`/power/dut/${this.id}`, { schema: dutState });\n  }\n\n  /**\n   * Reads the current drawn by the DUT.\n   * @returns The current drawn by the DUT.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n\n  /**\n   * Reads the voltage supplied to the DUT.\n   * @returns The voltage supplied to the DUT.\n   */\n  async read_voltage(): Promise<number> {\n    return (await this.read()).voltage;\n  }\n}\n\n/** @hideconstructor */\nexport class Usb {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Resets the USB port.\n   */\n  reset(): Promise<void> {\n    return this.fetch(`/power/usb/${this.id}/reset`, { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Configures the USB port.\n   * @param config The configuration to apply.\n   * @returns The updated USB state.\n   */\n  configure(config: UsbConfiguration): Promise<UsbState> {\n    return this.fetch(`/power/usb/${this.id}`, {\n      method: 'PATCH',\n      body: v.parse(usbConfiguration, config),\n      schema: usbState,\n    });\n  }\n\n  /**\n   * Enables the USB port power.\n   * @returns The updated USB state.\n   */\n  enable(): Promise<UsbState> {\n    return this.configure({ enabled: true });\n  }\n\n  /**\n   * Disables the USB port power.\n   * @returns The updated USB state.\n   */\n  disable(): Promise<UsbState> {\n    return this.configure({ enabled: false });\n  }\n\n  /**\n   * Reads the current state of the USB port.\n   * @returns The current USB state.\n   */\n  read(): Promise<UsbState> {\n    return this.fetch(`/power/usb/${this.id}`, { schema: usbState });\n  }\n\n  /**\n   * Reads the current drawn by the USB port.\n   * @returns The current drawn by the USB port.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n\n  /**\n   * Reads the voltage at the USB port.\n   * @returns The voltage at the USB port.\n   */\n  async read_voltage(): Promise<number> {\n    return (await this.read()).voltage;\n  }\n}\n\n/** @hideconstructor */\nexport class RelayPower {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Reads the current state of the relay.\n   * @returns The current relay state.\n   */\n  read(): Promise<RelayState> {\n    return this.fetch(`/power/relay/${this.id}`, { schema: relayState });\n  }\n\n  /**\n   * Reads the current drawn through the relay.\n   * @returns The current drawn through the relay.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n}\n"],"mappings":"oEAQA,MAAM,EAAW,EAAE,OAAO,CACxB,QAAS,EAAE,QAAQ,EACnB,eAAgB,EAChB,QAAS,EACT,QAAS,EAAE,OAAO,CACpB,CAAC,EAGK,EAAmB,EAAE,QAAQ,EAAE,KAAK,EAAU,CAAC,UAAW,gBAAgB,CAAC,CAAC,EAG5E,EAAW,EAAE,KAAK,EAAU,CAAC,UAAW,UAAW,SAAS,CAAC,EAG7D,EAAmB,EAAE,KAAK,EAAU,CAAC,SAAS,CAAC,EAG/C,EAAa,EAAE,KAAK,EAAU,CAAC,SAAS,CAAC,EAI/C,IAAa,EAAb,KAAsB,CAIS,MAH7B,UACA,UAA6B,EAE7B,YAAY,EAAiC,EAAmB,CAAnC,KAAA,MAAA,EAC3B,KAAK,UAAY,EAAK,aAAa,UAAU,QAAQ,EAAG,IAAM,EAAI,EAAE,MAAO,CAAC,CAC9E,CAKA,OAAuB,CACrB,OAAO,KAAK,MAAM,eAAgB,CAAE,OAAQ,OAAQ,kBAAqB,CAAC,CAAE,CAAC,CAC/E,CAOA,IAAI,EAAiB,CACnB,GAAI,EAAK,GAAK,GAAM,KAAK,UACvB,MAAU,MACR,kBAAkB,EAAG,oEACnB,KAAK,UAAY,EAClB,yBAAyB,GAC5B,EAGF,OAAO,IAAI,EAAI,KAAK,MAAO,CAAE,CAC/B,CAOA,IAAI,EAAiB,CACnB,GAAI,EAAK,GAAK,GAAM,KAAK,UACvB,MAAU,MACR,oBAAoB,EAAG,yEACrB,KAAK,UAAY,EAClB,yBAAyB,GAC5B,EAGF,OAAO,IAAI,EAAI,KAAK,MAAO,CAAE,CAC/B,CAMA,SAAsB,CACpB,OAAO,IAAI,EAAW,KAAK,MAAO,CAAC,CACrC,CACF,EAGa,EAAb,KAAiB,CACc,MAAgC,GAA7D,YAAY,EAAiC,EAA4B,CAA5C,KAAA,MAAA,EAAgC,KAAA,GAAA,CAAa,CAK1E,OAAuB,CACrB,OAAO,KAAK,MAAM,cAAc,KAAK,GAAG,QAAS,CAAE,OAAQ,OAAQ,kBAAqB,CAAC,CAAE,CAAC,CAC9F,CAOA,UAAU,EAA6C,CACrD,OAAO,KAAK,MAAM,cAAc,KAAK,KAAM,CACzC,OAAQ,QACR,KAAM,EAAE,MAAM,EAAkB,CAAM,EACtC,OAAQ,CACV,CAAC,CACH,CAOA,OAAO,EAA+C,CACpD,OAAO,KAAK,UAAU,CAAE,QAAS,GAAM,eAAgB,CAAQ,CAAC,CAClE,CAMA,SAA6B,CAC3B,OAAO,KAAK,UAAU,CAAE,QAAS,EAAM,CAAC,CAC1C,CAMA,MAA0B,CACxB,OAAO,KAAK,MAAM,cAAc,KAAK,KAAM,CAAE,OAAQ,CAAS,CAAC,CACjE,CAMA,MAAM,cAAgC,CACpC,OAAQ,MAAM,KAAK,KAAK,EAAA,CAAG,OAC7B,CAMA,MAAM,cAAgC,CACpC,OAAQ,MAAM,KAAK,KAAK,EAAA,CAAG,OAC7B,CACF,EAGa,EAAb,KAAiB,CACc,MAAgC,GAA7D,YAAY,EAAiC,EAA4B,CAA5C,KAAA,MAAA,EAAgC,KAAA,GAAA,CAAa,CAK1E,OAAuB,CACrB,OAAO,KAAK,MAAM,cAAc,KAAK,GAAG,QAAS,CAAE,OAAQ,OAAQ,kBAAqB,CAAC,CAAE,CAAC,CAC9F,CAOA,UAAU,EAA6C,CACrD,OAAO,KAAK,MAAM,cAAc,KAAK,KAAM,CACzC,OAAQ,QACR,KAAM,EAAE,MAAM,EAAkB,CAAM,EACtC,OAAQ,CACV,CAAC,CACH,CAMA,QAA4B,CAC1B,OAAO,KAAK,UAAU,CAAE,QAAS,EAAK,CAAC,CACzC,CAMA,SAA6B,CAC3B,OAAO,KAAK,UAAU,CAAE,QAAS,EAAM,CAAC,CAC1C,CAMA,MAA0B,CACxB,OAAO,KAAK,MAAM,cAAc,KAAK,KAAM,CAAE,OAAQ,CAAS,CAAC,CACjE,CAMA,MAAM,cAAgC,CACpC,OAAQ,MAAM,KAAK,KAAK,EAAA,CAAG,OAC7B,CAMA,MAAM,cAAgC,CACpC,OAAQ,MAAM,KAAK,KAAK,EAAA,CAAG,OAC7B,CACF,EAGa,EAAb,KAAwB,CACO,MAAgC,GAA7D,YAAY,EAAiC,EAA4B,CAA5C,KAAA,MAAA,EAAgC,KAAA,GAAA,CAAa,CAM1E,MAA4B,CAC1B,OAAO,KAAK,MAAM,gBAAgB,KAAK,KAAM,CAAE,OAAQ,CAAW,CAAC,CACrE,CAMA,MAAM,cAAgC,CACpC,OAAQ,MAAM,KAAK,KAAK,EAAA,CAAG,OAC7B,CACF"}
+{"version":3,"file":"power.mjs","names":[],"sources":["../src/api/power.ts"],"sourcesContent":["import type { UpFetch } from 'up-fetch';\nimport * as v from 'valibot';\n\nimport { analogLevel, type AnalogOutputLevel } from './common';\nimport type { Information } from './management';\n\nexport type { AnalogOutputLevel };\n\nexport const dutState = v.object({\n  enabled: v.boolean(),\n  target_voltage: analogLevel,\n  voltage: analogLevel,\n  current: v.number(),\n});\nexport type DutState = v.InferOutput<typeof dutState>;\n\nconst dutConfiguration = v.partial(v.pick(dutState, ['enabled', 'target_voltage']));\nexport type DutConfiguration = v.InferOutput<typeof dutConfiguration>;\n\nexport const usbState = v.pick(dutState, ['enabled', 'current', 'voltage']);\nexport type UsbState = v.InferOutput<typeof usbState>;\n\nconst usbConfiguration = v.pick(usbState, ['enabled']);\nexport type UsbConfiguration = v.InferOutput<typeof usbConfiguration>;\n\nconst relayState = v.pick(dutState, ['current']);\nexport type RelayState = v.InferOutput<typeof relayState>;\n\n/** @hideconstructor */\nexport class PowerApi {\n  private readonly usb_count: number;\n  private readonly dut_count = 1;\n\n  constructor(private readonly fetch: UpFetch, info: Information) {\n    this.usb_count = info.capabilities.usb_ports.reduce((a, b) => a + b.count, 0);\n  }\n\n  /**\n   * Resets the power API.\n   */\n  reset(): Promise<void> {\n    return this.fetch('/power/reset', { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Access a specific DUT by id.\n   * @param id The DUT id.\n   * @returns The DUT instance.\n   */\n  dut(id: number): Dut {\n    if (id < 0 || id >= this.dut_count) {\n      throw new Error(\n        `Invalid DUT id ${id} (RESOURCE_NOT_FOUND)\\n    Suggestion: Use a DUT ID between 0 and ${\n          this.dut_count - 1\n        }\\n    Path: /power/dut/${id}`,\n      );\n    }\n\n    return new Dut(this.fetch, id);\n  }\n\n  /**\n   * Access a specific USB port by id.\n   * @param id The USB port id.\n   * @returns The USB port instance.\n   */\n  usb(id: number): Usb {\n    if (id < 0 || id >= this.usb_count) {\n      throw new Error(\n        `Invalid USB port ${id} (RESOURCE_NOT_FOUND)\\n    Suggestion: Use a USB port ID between 0 and ${\n          this.usb_count - 1\n        }\\n    Path: /power/usb/${id}`,\n      );\n    }\n\n    return new Usb(this.fetch, id);\n  }\n\n  /**\n   * Access the relay at index 0.\n   * @returns The relay instance.\n   */\n  relay_0(): RelayPower {\n    return new RelayPower(this.fetch, 0);\n  }\n}\n\n/** @hideconstructor */\nexport class Dut {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Resets the DUT.\n   */\n  reset(): Promise<void> {\n    return this.fetch(`/power/dut/${this.id}/reset`, { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Configures the DUT.\n   * @param config The configuration to apply.\n   * @returns The updated DUT state.\n   */\n  configure(config: DutConfiguration): Promise<DutState> {\n    return this.fetch(`/power/dut/${this.id}`, {\n      method: 'PATCH',\n      body: v.parse(dutConfiguration, config),\n      schema: dutState,\n    });\n  }\n\n  /**\n   * Enables the DUT power supply at the specified voltage.\n   * @param voltage The target voltage to set.\n   * @returns The updated DUT state.\n   */\n  enable(voltage: AnalogOutputLevel): Promise<DutState> {\n    return this.configure({ enabled: true, target_voltage: voltage });\n  }\n\n  /**\n   * Disables the DUT power supply.\n   * @returns The updated DUT state.\n   */\n  disable(): Promise<DutState> {\n    return this.configure({ enabled: false });\n  }\n\n  /**\n   * Reads the current DUT state.\n   * @returns The current DUT state.\n   */\n  read(): Promise<DutState> {\n    return this.fetch(`/power/dut/${this.id}`, { schema: dutState });\n  }\n\n  /**\n   * Reads the current drawn by the DUT.\n   * @returns The current drawn by the DUT.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n\n  /**\n   * Reads the voltage supplied to the DUT.\n   * @returns The voltage supplied to the DUT.\n   */\n  async read_voltage(): Promise<number> {\n    return (await this.read()).voltage;\n  }\n}\n\n/** @hideconstructor */\nexport class Usb {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Resets the USB port.\n   */\n  reset(): Promise<void> {\n    return this.fetch(`/power/usb/${this.id}/reset`, { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Configures the USB port.\n   * @param config The configuration to apply.\n   * @returns The updated USB state.\n   */\n  configure(config: UsbConfiguration): Promise<UsbState> {\n    return this.fetch(`/power/usb/${this.id}`, {\n      method: 'PATCH',\n      body: v.parse(usbConfiguration, config),\n      schema: usbState,\n    });\n  }\n\n  /**\n   * Enables the USB port power.\n   * @returns The updated USB state.\n   */\n  enable(): Promise<UsbState> {\n    return this.configure({ enabled: true });\n  }\n\n  /**\n   * Disables the USB port power.\n   * @returns The updated USB state.\n   */\n  disable(): Promise<UsbState> {\n    return this.configure({ enabled: false });\n  }\n\n  /**\n   * Reads the current state of the USB port.\n   * @returns The current USB state.\n   */\n  read(): Promise<UsbState> {\n    return this.fetch(`/power/usb/${this.id}`, { schema: usbState });\n  }\n\n  /**\n   * Reads the current drawn by the USB port.\n   * @returns The current drawn by the USB port.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n\n  /**\n   * Reads the voltage at the USB port.\n   * @returns The voltage at the USB port.\n   */\n  async read_voltage(): Promise<number> {\n    return (await this.read()).voltage;\n  }\n}\n\n/** @hideconstructor */\nexport class RelayPower {\n  constructor(private readonly fetch: UpFetch, public readonly id: number) {}\n\n  /**\n   * Reads the current state of the relay.\n   * @returns The current relay state.\n   */\n  read(): Promise<RelayState> {\n    return this.fetch(`/power/relay/${this.id}`, { schema: relayState });\n  }\n\n  /**\n   * Reads the current drawn through the relay.\n   * @returns The current drawn through the relay.\n   */\n  async read_current(): Promise<number> {\n    return (await this.read()).current;\n  }\n}\n"],"mappings":"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"}

package/build/{relays-BCn6rQN1.d.cts → relays-8EGNIK1T.d.cts}

@@ -6,6 +6,9 @@ declare const state: v.PicklistSchema<["open", "closed"], undefined>;
 type State = v.InferOutput<typeof state>;
 declare const states: v.ArraySchema<v.PicklistSchema<["open", "closed"], undefined>, undefined>;
 type States = v.InferOutput<typeof states>;
+declare const relayState: v.ObjectSchema<{
+  readonly state: v.PicklistSchema<["open", "closed"], undefined>;
+}, undefined>;
 /** @hideconstructor */
 declare class RelaysApi {
   private readonly fetch;
@@ -76,5 +79,5 @@ declare class Relay {
   close(): Promise<State>;
 }
 //#endregion
-export { States as i, RelaysApi as n, State as r, Relay as t };
-//# sourceMappingURL=relays-BCn6rQN1.d.cts.map
+export { relayState as a, States as i, RelaysApi as n, states as o, State as r, Relay as t };
+//# sourceMappingURL=relays-8EGNIK1T.d.cts.map

package/build/relays-8EGNIK1T.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relays-8EGNIK1T.d.cts","names":[],"sources":["../src/api/relays.ts"],"mappings":";;;;cAGM,KAAA,EAAK,CAAA,CAAA,cAAA;AAAA,KACC,KAAA,GAAQ,CAAA,CAAE,WAAW,QAAQ,KAAA;AAAA,cAC5B,MAAA,EAAM,CAAA,CAAA,WAAA,CAAA,CAAA,CAAA,cAAA;AAAA,KACP,MAAA,GAAS,CAAA,CAAE,WAAW,QAAQ,MAAA;AAAA,cAC7B,UAAA,EAAU,CAAA,CAAA,YAAA;EAAA,gBAA6B,CAAA,CAAA,cAAA;AAAA;AAHpD;AAAA,cAUa,SAAA;EAAA,iBACkB,KAAA;cAAA,KAAA,EAAO,OAAA;EAXlB;;;EAgBlB,KAAA,IAAK,OAAA;EAhBuC;AAC9C;;;;EAwBE,KAAA,CAAM,EAAA,WAAa,KAAA;EAxBF;;;;EAgCjB,IAAA,IAAQ,OAAA,CAAQ,MAAA;EA/BN;;;;EAuCV,IAAA,IAAQ,OAAA,CAAQ,MAAA;EAvCK;;;AAAyB;EAmD9C,KAAA,IAAS,OAAA,CAAQ,MAAA;AAAA;;cAUN,KAAA;EAAA,iBAEQ,KAAA;EA9DE;;;EAAA,SAkEH,EAAA;cAJC,KAAA,EAAO,OAAA;;AAvD5B;;;EA2DoB,EAAA;EA1DkB;;;;EAiE9B,IAAA,IAAQ,OAAA,CAAQ,KAAA;EAnCN;;;;EA2CV,OAAA,IAAW,OAAA;EA/BD;;;;EAuCV,SAAA,IAAa,OAAA;EA5EnB;;;;EAoFM,IAAA,IAAQ,OAAA,CAAQ,KAAA;EAnEtB;;;;EAgFM,KAAA,IAAS,OAAA,CAAQ,KAAA;AAAA"}

package/build/{relays-BCn6rQN1.d.mts → relays-8EGNIK1T.d.mts}

@@ -6,6 +6,9 @@ declare const state: v.PicklistSchema<["open", "closed"], undefined>;
 type State = v.InferOutput<typeof state>;
 declare const states: v.ArraySchema<v.PicklistSchema<["open", "closed"], undefined>, undefined>;
 type States = v.InferOutput<typeof states>;
+declare const relayState: v.ObjectSchema<{
+  readonly state: v.PicklistSchema<["open", "closed"], undefined>;
+}, undefined>;
 /** @hideconstructor */
 declare class RelaysApi {
   private readonly fetch;
@@ -76,5 +79,5 @@ declare class Relay {
   close(): Promise<State>;
 }
 //#endregion
-export { States as i, RelaysApi as n, State as r, Relay as t };
-//# sourceMappingURL=relays-BCn6rQN1.d.mts.map
+export { relayState as a, States as i, RelaysApi as n, states as o, State as r, Relay as t };
+//# sourceMappingURL=relays-8EGNIK1T.d.mts.map

package/build/relays-8EGNIK1T.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relays-8EGNIK1T.d.mts","names":[],"sources":["../src/api/relays.ts"],"mappings":";;;;cAGM,KAAA,EAAK,CAAA,CAAA,cAAA;AAAA,KACC,KAAA,GAAQ,CAAA,CAAE,WAAW,QAAQ,KAAA;AAAA,cAC5B,MAAA,EAAM,CAAA,CAAA,WAAA,CAAA,CAAA,CAAA,cAAA;AAAA,KACP,MAAA,GAAS,CAAA,CAAE,WAAW,QAAQ,MAAA;AAAA,cAC7B,UAAA,EAAU,CAAA,CAAA,YAAA;EAAA,gBAA6B,CAAA,CAAA,cAAA;AAAA;AAHpD;AAAA,cAUa,SAAA;EAAA,iBACkB,KAAA;cAAA,KAAA,EAAO,OAAA;EAXlB;;;EAgBlB,KAAA,IAAK,OAAA;EAhBuC;AAC9C;;;;EAwBE,KAAA,CAAM,EAAA,WAAa,KAAA;EAxBF;;;;EAgCjB,IAAA,IAAQ,OAAA,CAAQ,MAAA;EA/BN;;;;EAuCV,IAAA,IAAQ,OAAA,CAAQ,MAAA;EAvCK;;;AAAyB;EAmD9C,KAAA,IAAS,OAAA,CAAQ,MAAA;AAAA;;cAUN,KAAA;EAAA,iBAEQ,KAAA;EA9DE;;;EAAA,SAkEH,EAAA;cAJC,KAAA,EAAO,OAAA;;AAvD5B;;;EA2DoB,EAAA;EA1DkB;;;;EAiE9B,IAAA,IAAQ,OAAA,CAAQ,KAAA;EAnCN;;;;EA2CV,OAAA,IAAW,OAAA;EA/BD;;;;EAuCV,SAAA,IAAa,OAAA;EA5EnB;;;;EAoFM,IAAA,IAAQ,OAAA,CAAQ,KAAA;EAnEtB;;;;EAgFM,KAAA,IAAS,OAAA,CAAQ,KAAA;AAAA"}

package/build/relays.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./chunk-CMqjfN_6.cjs");let t=require("valibot");t=e.t(t,1);const n=t.picklist([`open`,`closed`]),r=t.array(n),i=t.object({state:n}),a=t.picklist([`open`,`close`]);t.object({action:a});var o=class{fetch;constructor(e){this.fetch=e}reset(){return this.fetch(`/relays/reset`,{method:`POST`,parseResponse:()=>{}})}relay(e){return new s(this.fetch,e)}read(){return this.fetch(`/relays`,{schema:r})}open(){return this.fetch(`/relays`,{method:`POST`,body:{action:`open`},schema:r})}close(){return this.fetch(`/relays`,{method:`POST`,body:{action:`close`},schema:r})}},s=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}async read(){return(await this.fetch(`/relays/${this.id}`,{schema:i})).state}async is_open(){return await this.read()===`open`}async is_closed(){return await this.read()===`closed`}async open(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`open`},schema:i})).state}async close(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`close`},schema:i})).state}};exports.Relay=s,exports.RelaysApi=o;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./chunk-CMqjfN_6.cjs");let t=require("valibot");t=e.t(t,1);const n=t.picklist([`open`,`closed`]),r=t.array(n),i=t.object({state:n}),a=t.picklist([`open`,`close`]);t.object({action:a});var o=class{fetch;constructor(e){this.fetch=e}reset(){return this.fetch(`/relays/reset`,{method:`POST`,parseResponse:()=>{}})}relay(e){return new s(this.fetch,e)}read(){return this.fetch(`/relays`,{schema:r})}open(){return this.fetch(`/relays`,{method:`POST`,body:{action:`open`},schema:r})}close(){return this.fetch(`/relays`,{method:`POST`,body:{action:`close`},schema:r})}},s=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}async read(){return(await this.fetch(`/relays/${this.id}`,{schema:i})).state}async is_open(){return await this.read()===`open`}async is_closed(){return await this.read()===`closed`}async open(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`open`},schema:i})).state}async close(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`close`},schema:i})).state}};exports.Relay=s,exports.RelaysApi=o,exports.relayState=i,exports.states=r;
 //# sourceMappingURL=relays.cjs.map

package/build/relays.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"relays.cjs","names":["v"],"sources":["../src/api/relays.ts"],"sourcesContent":["import type { UpFetch } from 'up-fetch';\nimport * as v from 'valibot';\n\nconst state = v.picklist(['open', 'closed']);\nexport type State = v.InferOutput<typeof state>;\nconst states = v.array(state);\nexport type States = v.InferOutput<typeof states>;\nconst relayState = v.object({ state: state });\n\nconst action = v.picklist(['open', 'close']);\nconst relayAction = v.object({ action: action });\ntype RelayAction = v.InferOutput<typeof relayAction>;\n\n/** @hideconstructor */\nexport class RelaysApi {\n  constructor(private readonly fetch: UpFetch) {}\n\n  /**\n   * Resets all relays to their default state.\n   */\n  reset() {\n    return this.fetch('/relays/reset', { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Access a specific relay by id.\n   * @param id The relay id.\n   * @returns The relay instance.\n   */\n  relay(id: number): Relay {\n    return new Relay(this.fetch, id);\n  }\n\n  /**\n   * Reads the state of all relays.\n   * @returns The state of all relays.\n   */\n  read(): Promise<States> {\n    return this.fetch(`/relays`, { schema: states });\n  }\n\n  /**\n   * Opens all the relays.\n   * @returns The new state of all relays.\n   */\n  open(): Promise<States> {\n    return this.fetch(`/relays`, {\n      method: 'POST',\n      body: { action: 'open' } satisfies RelayAction,\n      schema: states,\n    });\n  }\n\n  /**\n   * Closes all the relays.\n   * @returns The new state of all relays.\n   */\n  close(): Promise<States> {\n    return this.fetch(`/relays`, {\n      method: 'POST',\n      body: { action: 'close' } satisfies RelayAction,\n      schema: states,\n    });\n  }\n}\n\n/** @hideconstructor */\nexport class Relay {\n  constructor(\n    private readonly fetch: UpFetch,\n    /**\n     * The relay id.\n     */\n    public readonly id: number,\n  ) {}\n\n  /**\n   * Reads the state of the relay.\n   * @returns The relay state.\n   */\n  async read(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, { schema: relayState })).state;\n  }\n\n  /**\n   * Returns whether the relay is open.\n   * @returns True if the relay is open, false otherwise.\n   */\n  async is_open(): Promise<boolean> {\n    return (await this.read()) === 'open';\n  }\n\n  /**\n   * Returns whether the relay is closed.\n   * @returns True if the relay is closed, false otherwise.\n   */\n  async is_closed(): Promise<boolean> {\n    return (await this.read()) === 'closed';\n  }\n\n  /**\n   * Opens the relay.\n   * @returns The new relay state.\n   */\n  async open(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, {\n      method: 'POST',\n      body: { action: 'open' } satisfies RelayAction,\n      schema: relayState,\n    }))\n      .state;\n  }\n\n  /**\n   * Closes the relay.\n   * @returns The new relay state.\n   */\n  async close(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, {\n      method: 'POST',\n      body: { action: 'close' } satisfies RelayAction,\n      schema: relayState,\n    }))\n      .state;\n  }\n}\n"],"mappings":"+IAGA,MAAM,EAAQA,EAAE,SAAS,CAAC,OAAQ,QAAQ,CAAC,EAErC,EAASA,EAAE,MAAM,CAAK,EAEtB,EAAaA,EAAE,OAAO,CAAS,OAAM,CAAC,EAEtC,EAASA,EAAE,SAAS,CAAC,OAAQ,OAAO,CAAC,EACvBA,EAAE,OAAO,CAAU,QAAO,CAAC,EAI/C,IAAa,EAAb,KAAuB,CACQ,MAA7B,YAAY,EAAiC,CAAhB,KAAA,MAAA,CAAiB,CAK9C,OAAQ,CACN,OAAO,KAAK,MAAM,gBAAiB,CAAE,OAAQ,OAAQ,kBAAqB,CAAC,CAAE,CAAC,CAChF,CAOA,MAAM,EAAmB,CACvB,OAAO,IAAI,EAAM,KAAK,MAAO,CAAE,CACjC,CAMA,MAAwB,CACtB,OAAO,KAAK,MAAM,UAAW,CAAE,OAAQ,CAAO,CAAC,CACjD,CAMA,MAAwB,CACtB,OAAO,KAAK,MAAM,UAAW,CAC3B,OAAQ,OACR,KAAM,CAAE,OAAQ,MAAO,EACvB,OAAQ,CACV,CAAC,CACH,CAMA,OAAyB,CACvB,OAAO,KAAK,MAAM,UAAW,CAC3B,OAAQ,OACR,KAAM,CAAE,OAAQ,OAAQ,EACxB,OAAQ,CACV,CAAC,CACH,CACF,EAGa,EAAb,KAAmB,CAEE,MAID,GALlB,YACE,EAIA,EACA,CALiB,KAAA,MAAA,EAID,KAAA,GAAA,CACf,CAMH,MAAM,MAAuB,CAC3B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAAE,OAAQ,CAAW,CAAC,EAAA,CAAG,KAC1E,CAMA,MAAM,SAA4B,CAChC,OAAQ,MAAM,KAAK,KAAK,IAAO,MACjC,CAMA,MAAM,WAA8B,CAClC,OAAQ,MAAM,KAAK,KAAK,IAAO,QACjC,CAMA,MAAM,MAAuB,CAC3B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAC7C,OAAQ,OACR,KAAM,CAAE,OAAQ,MAAO,EACvB,OAAQ,CACV,CAAC,EAAA,CACE,KACL,CAMA,MAAM,OAAwB,CAC5B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAC7C,OAAQ,OACR,KAAM,CAAE,OAAQ,OAAQ,EACxB,OAAQ,CACV,CAAC,EAAA,CACE,KACL,CACF"}
+{"version":3,"file":"relays.cjs","names":["v"],"sources":["../src/api/relays.ts"],"sourcesContent":["import type { UpFetch } from 'up-fetch';\nimport * as v from 'valibot';\n\nconst state = v.picklist(['open', 'closed']);\nexport type State = v.InferOutput<typeof state>;\nexport const states = v.array(state);\nexport type States = v.InferOutput<typeof states>;\nexport const relayState = v.object({ state: state });\n\nconst action = v.picklist(['open', 'close']);\nconst relayAction = v.object({ action: action });\ntype RelayAction = v.InferOutput<typeof relayAction>;\n\n/** @hideconstructor */\nexport class RelaysApi {\n  constructor(private readonly fetch: UpFetch) {}\n\n  /**\n   * Resets all relays to their default state.\n   */\n  reset() {\n    return this.fetch('/relays/reset', { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Access a specific relay by id.\n   * @param id The relay id.\n   * @returns The relay instance.\n   */\n  relay(id: number): Relay {\n    return new Relay(this.fetch, id);\n  }\n\n  /**\n   * Reads the state of all relays.\n   * @returns The state of all relays.\n   */\n  read(): Promise<States> {\n    return this.fetch(`/relays`, { schema: states });\n  }\n\n  /**\n   * Opens all the relays.\n   * @returns The new state of all relays.\n   */\n  open(): Promise<States> {\n    return this.fetch(`/relays`, {\n      method: 'POST',\n      body: { action: 'open' } satisfies RelayAction,\n      schema: states,\n    });\n  }\n\n  /**\n   * Closes all the relays.\n   * @returns The new state of all relays.\n   */\n  close(): Promise<States> {\n    return this.fetch(`/relays`, {\n      method: 'POST',\n      body: { action: 'close' } satisfies RelayAction,\n      schema: states,\n    });\n  }\n}\n\n/** @hideconstructor */\nexport class Relay {\n  constructor(\n    private readonly fetch: UpFetch,\n    /**\n     * The relay id.\n     */\n    public readonly id: number,\n  ) {}\n\n  /**\n   * Reads the state of the relay.\n   * @returns The relay state.\n   */\n  async read(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, { schema: relayState })).state;\n  }\n\n  /**\n   * Returns whether the relay is open.\n   * @returns True if the relay is open, false otherwise.\n   */\n  async is_open(): Promise<boolean> {\n    return (await this.read()) === 'open';\n  }\n\n  /**\n   * Returns whether the relay is closed.\n   * @returns True if the relay is closed, false otherwise.\n   */\n  async is_closed(): Promise<boolean> {\n    return (await this.read()) === 'closed';\n  }\n\n  /**\n   * Opens the relay.\n   * @returns The new relay state.\n   */\n  async open(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, {\n      method: 'POST',\n      body: { action: 'open' } satisfies RelayAction,\n      schema: relayState,\n    }))\n      .state;\n  }\n\n  /**\n   * Closes the relay.\n   * @returns The new relay state.\n   */\n  async close(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, {\n      method: 'POST',\n      body: { action: 'close' } satisfies RelayAction,\n      schema: relayState,\n    }))\n      .state;\n  }\n}\n"],"mappings":"+IAGA,MAAM,EAAQA,EAAE,SAAS,CAAC,OAAQ,QAAQ,CAAC,EAE9B,EAASA,EAAE,MAAM,CAAK,EAEtB,EAAaA,EAAE,OAAO,CAAS,OAAM,CAAC,EAE7C,EAASA,EAAE,SAAS,CAAC,OAAQ,OAAO,CAAC,EACvBA,EAAE,OAAO,CAAU,QAAO,CAAC,EAI/C,IAAa,EAAb,KAAuB,CACQ,MAA7B,YAAY,EAAiC,CAAhB,KAAA,MAAA,CAAiB,CAK9C,OAAQ,CACN,OAAO,KAAK,MAAM,gBAAiB,CAAE,OAAQ,OAAQ,kBAAqB,CAAC,CAAE,CAAC,CAChF,CAOA,MAAM,EAAmB,CACvB,OAAO,IAAI,EAAM,KAAK,MAAO,CAAE,CACjC,CAMA,MAAwB,CACtB,OAAO,KAAK,MAAM,UAAW,CAAE,OAAQ,CAAO,CAAC,CACjD,CAMA,MAAwB,CACtB,OAAO,KAAK,MAAM,UAAW,CAC3B,OAAQ,OACR,KAAM,CAAE,OAAQ,MAAO,EACvB,OAAQ,CACV,CAAC,CACH,CAMA,OAAyB,CACvB,OAAO,KAAK,MAAM,UAAW,CAC3B,OAAQ,OACR,KAAM,CAAE,OAAQ,OAAQ,EACxB,OAAQ,CACV,CAAC,CACH,CACF,EAGa,EAAb,KAAmB,CAEE,MAID,GALlB,YACE,EAIA,EACA,CALiB,KAAA,MAAA,EAID,KAAA,GAAA,CACf,CAMH,MAAM,MAAuB,CAC3B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAAE,OAAQ,CAAW,CAAC,EAAA,CAAG,KAC1E,CAMA,MAAM,SAA4B,CAChC,OAAQ,MAAM,KAAK,KAAK,IAAO,MACjC,CAMA,MAAM,WAA8B,CAClC,OAAQ,MAAM,KAAK,KAAK,IAAO,QACjC,CAMA,MAAM,MAAuB,CAC3B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAC7C,OAAQ,OACR,KAAM,CAAE,OAAQ,MAAO,EACvB,OAAQ,CACV,CAAC,EAAA,CACE,KACL,CAMA,MAAM,OAAwB,CAC5B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAC7C,OAAQ,OACR,KAAM,CAAE,OAAQ,OAAQ,EACxB,OAAQ,CACV,CAAC,EAAA,CACE,KACL,CACF"}

package/build/relays.d.cts

@@ -1,2 +1,2 @@
-import { i as States, n as RelaysApi, r as State, t as Relay } from "./relays-BCn6rQN1.cjs";
-export { Relay, RelaysApi, State, States };
+import { a as relayState, i as States, n as RelaysApi, o as states, r as State, t as Relay } from "./relays-8EGNIK1T.cjs";
+export { Relay, RelaysApi, State, States, relayState, states };

package/build/relays.d.mts

@@ -1,2 +1,2 @@
-import { i as States, n as RelaysApi, r as State, t as Relay } from "./relays-BCn6rQN1.mjs";
-export { Relay, RelaysApi, State, States };
+import { a as relayState, i as States, n as RelaysApi, o as states, r as State, t as Relay } from "./relays-8EGNIK1T.mjs";
+export { Relay, RelaysApi, State, States, relayState, states };

package/build/relays.mjs

@@ -1,2 +1,2 @@
-import*as e from"valibot";const t=e.picklist([`open`,`closed`]),n=e.array(t),r=e.object({state:t}),i=e.picklist([`open`,`close`]);e.object({action:i});var a=class{fetch;constructor(e){this.fetch=e}reset(){return this.fetch(`/relays/reset`,{method:`POST`,parseResponse:()=>{}})}relay(e){return new o(this.fetch,e)}read(){return this.fetch(`/relays`,{schema:n})}open(){return this.fetch(`/relays`,{method:`POST`,body:{action:`open`},schema:n})}close(){return this.fetch(`/relays`,{method:`POST`,body:{action:`close`},schema:n})}},o=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}async read(){return(await this.fetch(`/relays/${this.id}`,{schema:r})).state}async is_open(){return await this.read()===`open`}async is_closed(){return await this.read()===`closed`}async open(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`open`},schema:r})).state}async close(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`close`},schema:r})).state}};export{o as Relay,a as RelaysApi};
+import*as e from"valibot";const t=e.picklist([`open`,`closed`]),n=e.array(t),r=e.object({state:t}),i=e.picklist([`open`,`close`]);e.object({action:i});var a=class{fetch;constructor(e){this.fetch=e}reset(){return this.fetch(`/relays/reset`,{method:`POST`,parseResponse:()=>{}})}relay(e){return new o(this.fetch,e)}read(){return this.fetch(`/relays`,{schema:n})}open(){return this.fetch(`/relays`,{method:`POST`,body:{action:`open`},schema:n})}close(){return this.fetch(`/relays`,{method:`POST`,body:{action:`close`},schema:n})}},o=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}async read(){return(await this.fetch(`/relays/${this.id}`,{schema:r})).state}async is_open(){return await this.read()===`open`}async is_closed(){return await this.read()===`closed`}async open(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`open`},schema:r})).state}async close(){return(await this.fetch(`/relays/${this.id}`,{method:`POST`,body:{action:`close`},schema:r})).state}};export{o as Relay,a as RelaysApi,r as relayState,n as states};
 //# sourceMappingURL=relays.mjs.map

package/build/relays.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"relays.mjs","names":[],"sources":["../src/api/relays.ts"],"sourcesContent":["import type { UpFetch } from 'up-fetch';\nimport * as v from 'valibot';\n\nconst state = v.picklist(['open', 'closed']);\nexport type State = v.InferOutput<typeof state>;\nconst states = v.array(state);\nexport type States = v.InferOutput<typeof states>;\nconst relayState = v.object({ state: state });\n\nconst action = v.picklist(['open', 'close']);\nconst relayAction = v.object({ action: action });\ntype RelayAction = v.InferOutput<typeof relayAction>;\n\n/** @hideconstructor */\nexport class RelaysApi {\n  constructor(private readonly fetch: UpFetch) {}\n\n  /**\n   * Resets all relays to their default state.\n   */\n  reset() {\n    return this.fetch('/relays/reset', { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Access a specific relay by id.\n   * @param id The relay id.\n   * @returns The relay instance.\n   */\n  relay(id: number): Relay {\n    return new Relay(this.fetch, id);\n  }\n\n  /**\n   * Reads the state of all relays.\n   * @returns The state of all relays.\n   */\n  read(): Promise<States> {\n    return this.fetch(`/relays`, { schema: states });\n  }\n\n  /**\n   * Opens all the relays.\n   * @returns The new state of all relays.\n   */\n  open(): Promise<States> {\n    return this.fetch(`/relays`, {\n      method: 'POST',\n      body: { action: 'open' } satisfies RelayAction,\n      schema: states,\n    });\n  }\n\n  /**\n   * Closes all the relays.\n   * @returns The new state of all relays.\n   */\n  close(): Promise<States> {\n    return this.fetch(`/relays`, {\n      method: 'POST',\n      body: { action: 'close' } satisfies RelayAction,\n      schema: states,\n    });\n  }\n}\n\n/** @hideconstructor */\nexport class Relay {\n  constructor(\n    private readonly fetch: UpFetch,\n    /**\n     * The relay id.\n     */\n    public readonly id: number,\n  ) {}\n\n  /**\n   * Reads the state of the relay.\n   * @returns The relay state.\n   */\n  async read(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, { schema: relayState })).state;\n  }\n\n  /**\n   * Returns whether the relay is open.\n   * @returns True if the relay is open, false otherwise.\n   */\n  async is_open(): Promise<boolean> {\n    return (await this.read()) === 'open';\n  }\n\n  /**\n   * Returns whether the relay is closed.\n   * @returns True if the relay is closed, false otherwise.\n   */\n  async is_closed(): Promise<boolean> {\n    return (await this.read()) === 'closed';\n  }\n\n  /**\n   * Opens the relay.\n   * @returns The new relay state.\n   */\n  async open(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, {\n      method: 'POST',\n      body: { action: 'open' } satisfies RelayAction,\n      schema: relayState,\n    }))\n      .state;\n  }\n\n  /**\n   * Closes the relay.\n   * @returns The new relay state.\n   */\n  async close(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, {\n      method: 'POST',\n      body: { action: 'close' } satisfies RelayAction,\n      schema: relayState,\n    }))\n      .state;\n  }\n}\n"],"mappings":"0BAGA,MAAM,EAAQ,EAAE,SAAS,CAAC,OAAQ,QAAQ,CAAC,EAErC,EAAS,EAAE,MAAM,CAAK,EAEtB,EAAa,EAAE,OAAO,CAAS,OAAM,CAAC,EAEtC,EAAS,EAAE,SAAS,CAAC,OAAQ,OAAO,CAAC,EACvB,EAAE,OAAO,CAAU,QAAO,CAAC,EAI/C,IAAa,EAAb,KAAuB,CACQ,MAA7B,YAAY,EAAiC,CAAhB,KAAA,MAAA,CAAiB,CAK9C,OAAQ,CACN,OAAO,KAAK,MAAM,gBAAiB,CAAE,OAAQ,OAAQ,kBAAqB,CAAC,CAAE,CAAC,CAChF,CAOA,MAAM,EAAmB,CACvB,OAAO,IAAI,EAAM,KAAK,MAAO,CAAE,CACjC,CAMA,MAAwB,CACtB,OAAO,KAAK,MAAM,UAAW,CAAE,OAAQ,CAAO,CAAC,CACjD,CAMA,MAAwB,CACtB,OAAO,KAAK,MAAM,UAAW,CAC3B,OAAQ,OACR,KAAM,CAAE,OAAQ,MAAO,EACvB,OAAQ,CACV,CAAC,CACH,CAMA,OAAyB,CACvB,OAAO,KAAK,MAAM,UAAW,CAC3B,OAAQ,OACR,KAAM,CAAE,OAAQ,OAAQ,EACxB,OAAQ,CACV,CAAC,CACH,CACF,EAGa,EAAb,KAAmB,CAEE,MAID,GALlB,YACE,EAIA,EACA,CALiB,KAAA,MAAA,EAID,KAAA,GAAA,CACf,CAMH,MAAM,MAAuB,CAC3B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAAE,OAAQ,CAAW,CAAC,EAAA,CAAG,KAC1E,CAMA,MAAM,SAA4B,CAChC,OAAQ,MAAM,KAAK,KAAK,IAAO,MACjC,CAMA,MAAM,WAA8B,CAClC,OAAQ,MAAM,KAAK,KAAK,IAAO,QACjC,CAMA,MAAM,MAAuB,CAC3B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAC7C,OAAQ,OACR,KAAM,CAAE,OAAQ,MAAO,EACvB,OAAQ,CACV,CAAC,EAAA,CACE,KACL,CAMA,MAAM,OAAwB,CAC5B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAC7C,OAAQ,OACR,KAAM,CAAE,OAAQ,OAAQ,EACxB,OAAQ,CACV,CAAC,EAAA,CACE,KACL,CACF"}
+{"version":3,"file":"relays.mjs","names":[],"sources":["../src/api/relays.ts"],"sourcesContent":["import type { UpFetch } from 'up-fetch';\nimport * as v from 'valibot';\n\nconst state = v.picklist(['open', 'closed']);\nexport type State = v.InferOutput<typeof state>;\nexport const states = v.array(state);\nexport type States = v.InferOutput<typeof states>;\nexport const relayState = v.object({ state: state });\n\nconst action = v.picklist(['open', 'close']);\nconst relayAction = v.object({ action: action });\ntype RelayAction = v.InferOutput<typeof relayAction>;\n\n/** @hideconstructor */\nexport class RelaysApi {\n  constructor(private readonly fetch: UpFetch) {}\n\n  /**\n   * Resets all relays to their default state.\n   */\n  reset() {\n    return this.fetch('/relays/reset', { method: 'POST', parseResponse: () => {} });\n  }\n\n  /**\n   * Access a specific relay by id.\n   * @param id The relay id.\n   * @returns The relay instance.\n   */\n  relay(id: number): Relay {\n    return new Relay(this.fetch, id);\n  }\n\n  /**\n   * Reads the state of all relays.\n   * @returns The state of all relays.\n   */\n  read(): Promise<States> {\n    return this.fetch(`/relays`, { schema: states });\n  }\n\n  /**\n   * Opens all the relays.\n   * @returns The new state of all relays.\n   */\n  open(): Promise<States> {\n    return this.fetch(`/relays`, {\n      method: 'POST',\n      body: { action: 'open' } satisfies RelayAction,\n      schema: states,\n    });\n  }\n\n  /**\n   * Closes all the relays.\n   * @returns The new state of all relays.\n   */\n  close(): Promise<States> {\n    return this.fetch(`/relays`, {\n      method: 'POST',\n      body: { action: 'close' } satisfies RelayAction,\n      schema: states,\n    });\n  }\n}\n\n/** @hideconstructor */\nexport class Relay {\n  constructor(\n    private readonly fetch: UpFetch,\n    /**\n     * The relay id.\n     */\n    public readonly id: number,\n  ) {}\n\n  /**\n   * Reads the state of the relay.\n   * @returns The relay state.\n   */\n  async read(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, { schema: relayState })).state;\n  }\n\n  /**\n   * Returns whether the relay is open.\n   * @returns True if the relay is open, false otherwise.\n   */\n  async is_open(): Promise<boolean> {\n    return (await this.read()) === 'open';\n  }\n\n  /**\n   * Returns whether the relay is closed.\n   * @returns True if the relay is closed, false otherwise.\n   */\n  async is_closed(): Promise<boolean> {\n    return (await this.read()) === 'closed';\n  }\n\n  /**\n   * Opens the relay.\n   * @returns The new relay state.\n   */\n  async open(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, {\n      method: 'POST',\n      body: { action: 'open' } satisfies RelayAction,\n      schema: relayState,\n    }))\n      .state;\n  }\n\n  /**\n   * Closes the relay.\n   * @returns The new relay state.\n   */\n  async close(): Promise<State> {\n    return (await this.fetch(`/relays/${this.id}`, {\n      method: 'POST',\n      body: { action: 'close' } satisfies RelayAction,\n      schema: relayState,\n    }))\n      .state;\n  }\n}\n"],"mappings":"0BAGA,MAAM,EAAQ,EAAE,SAAS,CAAC,OAAQ,QAAQ,CAAC,EAE9B,EAAS,EAAE,MAAM,CAAK,EAEtB,EAAa,EAAE,OAAO,CAAS,OAAM,CAAC,EAE7C,EAAS,EAAE,SAAS,CAAC,OAAQ,OAAO,CAAC,EACvB,EAAE,OAAO,CAAU,QAAO,CAAC,EAI/C,IAAa,EAAb,KAAuB,CACQ,MAA7B,YAAY,EAAiC,CAAhB,KAAA,MAAA,CAAiB,CAK9C,OAAQ,CACN,OAAO,KAAK,MAAM,gBAAiB,CAAE,OAAQ,OAAQ,kBAAqB,CAAC,CAAE,CAAC,CAChF,CAOA,MAAM,EAAmB,CACvB,OAAO,IAAI,EAAM,KAAK,MAAO,CAAE,CACjC,CAMA,MAAwB,CACtB,OAAO,KAAK,MAAM,UAAW,CAAE,OAAQ,CAAO,CAAC,CACjD,CAMA,MAAwB,CACtB,OAAO,KAAK,MAAM,UAAW,CAC3B,OAAQ,OACR,KAAM,CAAE,OAAQ,MAAO,EACvB,OAAQ,CACV,CAAC,CACH,CAMA,OAAyB,CACvB,OAAO,KAAK,MAAM,UAAW,CAC3B,OAAQ,OACR,KAAM,CAAE,OAAQ,OAAQ,EACxB,OAAQ,CACV,CAAC,CACH,CACF,EAGa,EAAb,KAAmB,CAEE,MAID,GALlB,YACE,EAIA,EACA,CALiB,KAAA,MAAA,EAID,KAAA,GAAA,CACf,CAMH,MAAM,MAAuB,CAC3B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAAE,OAAQ,CAAW,CAAC,EAAA,CAAG,KAC1E,CAMA,MAAM,SAA4B,CAChC,OAAQ,MAAM,KAAK,KAAK,IAAO,MACjC,CAMA,MAAM,WAA8B,CAClC,OAAQ,MAAM,KAAK,KAAK,IAAO,QACjC,CAMA,MAAM,MAAuB,CAC3B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAC7C,OAAQ,OACR,KAAM,CAAE,OAAQ,MAAO,EACvB,OAAQ,CACV,CAAC,EAAA,CACE,KACL,CAMA,MAAM,OAAwB,CAC5B,OAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,KAAM,CAC7C,OAAQ,OACR,KAAM,CAAE,OAAQ,OAAQ,EACxB,OAAQ,CACV,CAAC,EAAA,CACE,KACL,CACF"}