@ikalogic/at1000 0.1.26 → 0.1.28

package/build/power-Dv21KxFx.d.cts

@@ -0,0 +1,343 @@
+import { t as AnalogOutputLevel } from "./common-DWQyDOs5.cjs";
+import { n as Information } from "./management-wQgti8p7.cjs";
+import { UpFetch } from "up-fetch";
+import * as v from "valibot";
+
+//#region src/api/power.d.ts
+declare const dutState: v.ObjectSchema<{
+  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>;
+}, undefined>;
+type DutState = v.InferOutput<typeof dutState>;
+declare const dutConfiguration: Omit<Omit<v.ObjectSchema<{
+  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>;
+}, undefined>, "~standard" | "~run" | "~types" | "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" | "target_voltage">;
+  readonly "~standard": v.StandardProps<{
+    enabled: boolean;
+    target_voltage: number;
+  }, {
+    enabled: boolean;
+    target_voltage: number;
+  }>;
+  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+    enabled: boolean;
+    target_voltage: number;
+  }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>>;
+  readonly "~types"?: {
+    readonly input: {
+      enabled: boolean;
+      target_voltage: number;
+    };
+    readonly output: {
+      enabled: boolean;
+      target_voltage: number;
+    };
+    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
+  } | undefined;
+}, "~standard" | "~run" | "~types" | "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>;
+  };
+  readonly "~standard": v.StandardProps<{
+    enabled?: boolean | undefined;
+    target_voltage?: number | undefined;
+  }, {
+    enabled?: boolean | undefined;
+    target_voltage?: number | undefined;
+  }>;
+  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+    enabled?: boolean | undefined;
+    target_voltage?: number | undefined;
+  }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>>;
+  readonly "~types"?: {
+    readonly input: {
+      enabled?: boolean | undefined;
+      target_voltage?: number | undefined;
+    };
+    readonly output: {
+      enabled?: boolean | undefined;
+      target_voltage?: number | undefined;
+    };
+    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
+  } | undefined;
+};
+type DutConfiguration = v.InferOutput<typeof dutConfiguration>;
+declare const usbState: Omit<v.ObjectSchema<{
+  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>;
+}, undefined>, "~standard" | "~run" | "~types" | "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">;
+  readonly "~standard": v.StandardProps<{
+    enabled: boolean;
+    current: number;
+    voltage: number;
+  }, {
+    enabled: boolean;
+    current: number;
+    voltage: number;
+  }>;
+  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+    enabled: boolean;
+    current: number;
+    voltage: 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;
+    };
+    readonly output: {
+      enabled: boolean;
+      current: number;
+      voltage: number;
+    };
+    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
+  } | undefined;
+};
+type UsbState = v.InferOutput<typeof usbState>;
+declare const usbConfiguration: Omit<Omit<v.ObjectSchema<{
+  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>;
+}, undefined>, "~standard" | "~run" | "~types" | "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">;
+  readonly "~standard": v.StandardProps<{
+    enabled: boolean;
+    current: number;
+    voltage: number;
+  }, {
+    enabled: boolean;
+    current: number;
+    voltage: number;
+  }>;
+  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+    enabled: boolean;
+    current: number;
+    voltage: 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;
+    };
+    readonly output: {
+      enabled: boolean;
+      current: number;
+      voltage: number;
+    };
+    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
+  } | undefined;
+}, "~standard" | "~run" | "~types" | "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">;
+  readonly "~standard": v.StandardProps<{
+    enabled: boolean;
+  }, {
+    enabled: boolean;
+  }>;
+  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+    enabled: boolean;
+  }, v.BooleanIssue | v.ObjectIssue>;
+  readonly "~types"?: {
+    readonly input: {
+      enabled: boolean;
+    };
+    readonly output: {
+      enabled: boolean;
+    };
+    readonly issue: v.BooleanIssue | v.ObjectIssue;
+  } | undefined;
+};
+type UsbConfiguration = v.InferOutput<typeof usbConfiguration>;
+declare const relayState: Omit<v.ObjectSchema<{
+  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>;
+}, undefined>, "~standard" | "~run" | "~types" | "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>;
+  }, "current">;
+  readonly "~standard": v.StandardProps<{
+    current: number;
+  }, {
+    current: number;
+  }>;
+  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+    current: number;
+  }, v.NumberIssue | v.ObjectIssue>;
+  readonly "~types"?: {
+    readonly input: {
+      current: number;
+    };
+    readonly output: {
+      current: number;
+    };
+    readonly issue: v.NumberIssue | v.ObjectIssue;
+  } | undefined;
+};
+type RelayState = v.InferOutput<typeof relayState>;
+/** @hideconstructor */
+declare class PowerApi {
+  private readonly fetch;
+  private readonly usb_count;
+  private readonly dut_count;
+  constructor(fetch: UpFetch, info: Information);
+  /**
+   * Resets the power API.
+   */
+  reset(): Promise<void>;
+  /**
+   * Access a specific DUT by id.
+   * @param id The DUT id.
+   * @returns The DUT instance.
+   */
+  dut(id: number): Dut;
+  /**
+   * Access a specific USB port by id.
+   * @param id The USB port id.
+   * @returns The USB port instance.
+   */
+  usb(id: number): Usb;
+  /**
+   * Access the relay at index 4.
+   * @returns The relay instance.
+   */
+  relay_4(): RelayPower;
+}
+/** @hideconstructor */
+declare class Dut {
+  private readonly fetch;
+  readonly id: number;
+  constructor(fetch: UpFetch, id: number);
+  /**
+   * Resets the DUT.
+   */
+  reset(): Promise<void>;
+  /**
+   * Configures the DUT.
+   * @param config The configuration to apply.
+   * @returns The updated DUT state.
+   */
+  configure(config: DutConfiguration): Promise<DutState>;
+  /**
+   * Enables the DUT power supply at the specified voltage.
+   * @param voltage The target voltage to set.
+   * @returns The updated DUT state.
+   */
+  enable(voltage: AnalogOutputLevel): Promise<DutState>;
+  /**
+   * Disables the DUT power supply.
+   * @returns The updated DUT state.
+   */
+  disable(): Promise<DutState>;
+  /**
+   * Reads the current DUT state.
+   * @returns The current DUT state.
+   */
+  read(): Promise<DutState>;
+  /**
+   * Reads the current drawn by the DUT.
+   * @returns The current drawn by the DUT.
+   */
+  read_current(): Promise<number>;
+  /**
+   * Reads the voltage supplied to the DUT.
+   * @returns The voltage supplied to the DUT.
+   */
+  read_voltage(): Promise<number>;
+}
+/** @hideconstructor */
+declare class Usb {
+  private readonly fetch;
+  readonly id: number;
+  constructor(fetch: UpFetch, id: number);
+  /**
+   * Resets the USB port.
+   */
+  reset(): Promise<void>;
+  /**
+   * Configures the USB port.
+   * @param config The configuration to apply.
+   * @returns The updated USB state.
+   */
+  configure(config: UsbConfiguration): Promise<UsbState>;
+  /**
+   * Enables the USB port power.
+   * @returns The updated USB state.
+   */
+  enable(): Promise<UsbState>;
+  /**
+   * Disables the USB port power.
+   * @returns The updated USB state.
+   */
+  disable(): Promise<UsbState>;
+  /**
+   * Reads the current state of the USB port.
+   * @returns The current USB state.
+   */
+  read(): Promise<UsbState>;
+  /**
+   * Reads the current drawn by the USB port.
+   * @returns The current drawn by the USB port.
+   */
+  read_current(): Promise<number>;
+  /**
+   * Reads the voltage at the USB port.
+   * @returns The voltage at the USB port.
+   */
+  read_voltage(): Promise<number>;
+}
+/** @hideconstructor */
+declare class RelayPower {
+  private readonly fetch;
+  readonly id: number;
+  constructor(fetch: UpFetch, id: number);
+  /**
+   * Reads the current state of the relay.
+   * @returns The current relay state.
+   */
+  read(): Promise<RelayState>;
+  /**
+   * Reads the current drawn through the relay.
+   * @returns The current drawn through the relay.
+   */
+  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-Dv21KxFx.d.cts.map

package/build/power-Dv21KxFx.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"power-Dv21KxFx.d.cts","names":[],"sources":["../src/api/power.ts"],"mappings":";;;;;;cAQM,QAAA,EAAQ,CAAA,CAAA,YAAA;EAAA;;;;;KAMF,QAAA,GAAW,CAAA,CAAE,WAAA,QAAmB,QAAA;AAAA,cAEtC,gBAAA,EAAgB,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACV,gBAAA,GAAmB,CAAA,CAAE,WAAA,QAAmB,gBAAA;AAAA,cAE9C,QAAA,EAAQ,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACF,QAAA,GAAW,CAAA,CAAE,WAAA,QAAmB,QAAA;AAAA,cAEtC,gBAAA,EAAgB,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACV,gBAAA,GAAmB,CAAA,CAAE,WAAA,QAAmB,gBAAA;AAAA,cAE9C,UAAA,EAAU,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACJ,UAAA,GAAa,CAAA,CAAE,WAAA,QAAmB,UAAA;;cAGjC,QAAA;EAAA,iBAIkB,KAAA;EAAA,iBAHZ,SAAA;EAAA,iBACA,SAAA;cAEY,KAAA,EAAO,OAAA,EAAS,IAAA,EAAM,WAAA;;;;EAOnD,KAAA,CAAA,GAAS,OAAA;;;;;;EAST,GAAA,CAAI,EAAA,WAAa,GAAA;;;;;;EAiBjB,GAAA,CAAI,EAAA,WAAa,GAAA;;;;;EAgBjB,OAAA,CAAA,GAAW,UAAA;AAAA;;cAMA,GAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;EAK7D,KAAA,CAAA,GAAS,OAAA;;;;;;EAST,SAAA,CAAU,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,QAAA;;;;;;EAa7C,MAAA,CAAO,OAAA,EAAS,iBAAA,GAAoB,OAAA,CAAQ,QAAA;;;;;EAQ5C,OAAA,CAAA,GAAW,OAAA,CAAQ,QAAA;;;;;EAQnB,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;;;;;EAQV,YAAA,CAAA,GAAgB,OAAA;;;;;EAQhB,YAAA,CAAA,GAAgB,OAAA;AAAA;;cAMX,GAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;EAK7D,KAAA,CAAA,GAAS,OAAA;;;;AA/IX;;EAwJE,SAAA,CAAU,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,QAAA;EAxJH;;;;EAoK1C,MAAA,CAAA,GAAU,OAAA,CAAQ,QAAA;EApKgD;AAAE;;;EA4KpE,OAAA,CAAA,GAAW,OAAA,CAAQ,QAAA;;;;;EAQnB,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;;;;;EAQV,YAAA,CAAA,GAAgB,OAAA;EA1LV;;;;EAkMN,YAAA,CAAA,GAAgB,OAAA;AAAA;;cAMX,UAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;;EAM7D,IAAA,CAAA,GAAQ,OAAA,CAAQ,UAAA;;;;;EAQV,YAAA,CAAA,GAAgB,OAAA;AAAA"}

package/build/power.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./chunk-Bmb41Sf3.cjs`),t=require(`./common-Bbc8Sixu.cjs`);let n=require(`valibot`);n=e.t(n);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{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_4(){return new d(this.fetch,4)}},l=class{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{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{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-Bmb41Sf3.cjs`),t=require(`./common-PXzrB8CC.cjs`);let n=require(`valibot`);n=e.t(n);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{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_4(){return new d(this.fetch,4)}},l=class{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{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{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;
 //# sourceMappingURL=power.cjs.map