@ikalogic/at1000 0.2.2 → 0.3.0

package/build/events-PyyK1XbE.d.mts

@@ -0,0 +1,351 @@
+import * as v from "valibot";
+
+//#region src/api/events.d.ts
+declare const eventDataSchemas: {
+  readonly 'com.can_config': v.ObjectSchema<{
+    readonly enabled: v.BooleanSchema<undefined>;
+    readonly baud_rate: v.PicklistSchema<[5000, 10000, 20000, 31250, 33000, 40000, 50000, 80000, 83300, 95000, 100000, 125000, 200000, 250000, 500000, 1000000], undefined>;
+    readonly termination_resistors: v.BooleanSchema<undefined>;
+    readonly rx_filter: v.ObjectSchema<{
+      readonly extended_id: v.BooleanSchema<undefined>;
+      readonly id: v.NumberSchema<undefined>;
+      readonly mask: v.NumberSchema<undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly 'com.rs232_config': v.ObjectSchema<{
+    readonly enabled: v.BooleanSchema<undefined>;
+    readonly baud_rate: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 50, undefined>, v.MaxValueAction<number, 1000000, undefined>]>;
+    readonly data_bits: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 7, undefined>, v.MaxValueAction<number, 8, undefined>]>;
+    readonly stop_bits: v.PicklistSchema<["1", "1.5", "2"], undefined>;
+    readonly parity: v.PicklistSchema<["none", "odd", "even", "mark", "space"], undefined>;
+  }, undefined>;
+  readonly 'com.rs485_config': v.ObjectSchema<{
+    readonly enabled: v.BooleanSchema<undefined>;
+    readonly baud_rate: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 300, undefined>, v.MaxValueAction<number, 20000000, undefined>]>;
+    readonly data_bits: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 7, undefined>, v.MaxValueAction<number, 8, undefined>]>;
+    readonly stop_bits: v.PicklistSchema<["1", "1.5", "2"], undefined>;
+    readonly parity: v.PicklistSchema<["none", "odd", "even", "mark", "space"], undefined>;
+    readonly termination_resistors: v.BooleanSchema<undefined>;
+  }, undefined>;
+  readonly 'com.spi_config': v.ObjectSchema<{
+    readonly enabled: v.BooleanSchema<undefined>;
+    readonly baud_rate: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 300, undefined>, v.MaxValueAction<number, 10000000, undefined>]>;
+    readonly vcc: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1.6, undefined>, v.MaxValueAction<number, 5, undefined>]>;
+    readonly mode: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 3, undefined>]>;
+  }, undefined>;
+  readonly 'com.i2c_config': v.ObjectSchema<{
+    readonly enabled: v.BooleanSchema<undefined>;
+    readonly baud_rate: v.PicklistSchema<[100000, 400000, 1000000], undefined>;
+    readonly vcc: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1.6, undefined>, v.MaxValueAction<number, 5, undefined>]>;
+  }, undefined>;
+  readonly 'com.uart_config': v.ObjectSchema<{
+    readonly enabled: v.BooleanSchema<undefined>;
+    readonly baud_rate: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 300, undefined>, v.MaxValueAction<number, 12000000, undefined>]>;
+    readonly vcc: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1.6, undefined>, v.MaxValueAction<number, 5, undefined>]>;
+    readonly data_bits: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 7, undefined>, v.MaxValueAction<number, 8, undefined>]>;
+    readonly stop_bits: v.PicklistSchema<["1", "1.5", "2"], undefined>;
+    readonly parity: v.PicklistSchema<["none", "odd", "even", "mark", "space"], undefined>;
+  }, undefined>;
+  readonly 'com.can_rx': v.ArraySchema<v.ObjectSchema<{
+    readonly id: v.NumberSchema<undefined>;
+    readonly extended_id: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+    readonly rtr: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+    readonly data: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.NumberSchema<undefined>, undefined>, v.MinLengthAction<number[], 0, undefined>, v.MaxLengthAction<number[], 8, undefined>]>, readonly []>;
+    readonly timeout: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 5000, undefined>]>, undefined>;
+  }, undefined>, undefined>;
+  readonly 'com.uart_rx': v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>, undefined>;
+  readonly 'com.rs232_rx': v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>, undefined>;
+  readonly 'com.rs485_rx': v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>, undefined>;
+  readonly 'gpio.state': v.UnionSchema<[v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
+  }, undefined>, v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+  }, undefined>], undefined>;
+  readonly 'gpio.config': v.UnionSchema<[v.ObjectSchema<{
+    readonly mode: v.LiteralSchema<"analog", undefined>;
+    readonly direction: v.LiteralSchema<"input", undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly mode: v.LiteralSchema<"analog", undefined>;
+    readonly direction: v.LiteralSchema<"output", undefined>;
+    readonly value: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly mode: v.LiteralSchema<"digital", undefined>;
+    readonly direction: v.LiteralSchema<"input", undefined>;
+    readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+    readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+  }, undefined>, v.ObjectSchema<{
+    readonly mode: v.LiteralSchema<"digital", undefined>;
+    readonly direction: v.LiteralSchema<"output", undefined>;
+    readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
+    readonly vol: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
+    readonly voh: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>;
+    readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+    readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+  }, undefined>, v.ObjectSchema<{
+    readonly mode: v.LiteralSchema<"digital", undefined>;
+    readonly direction: v.LiteralSchema<"open_drain", undefined>;
+    readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
+    readonly vil: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+    readonly vih: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+  }, undefined>], undefined>;
+  readonly 'gpio.sync': v.ObjectSchema<{
+    readonly hold_state: v.PicklistSchema<["held", "released"], undefined>;
+  }, undefined>;
+  readonly 'hmi.text': v.ObjectSchema<{
+    readonly text: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 1024, undefined>]>;
+  }, undefined>;
+  readonly 'hmi.colors': v.ObjectSchema<{
+    readonly text: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.LengthAction<string, 7, undefined>, v.HexColorAction<string, undefined>]>, undefined>;
+    readonly progress: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.LengthAction<string, 7, undefined>, v.HexColorAction<string, undefined>]>, undefined>;
+    readonly background: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.LengthAction<string, 7, undefined>, v.HexColorAction<string, undefined>]>, undefined>;
+  }, undefined>;
+  readonly 'hmi.progress': v.OptionalSchema<v.ObjectSchema<{
+    readonly progress: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 100, undefined>]>;
+  }, undefined>, undefined>;
+  readonly 'hmi.play': v.ObjectSchema<{
+    readonly sound_id: v.PicklistSchema<["success", "warning", "failure", "notification_1", "notification_2", "imperial_march"], undefined>;
+    readonly volume: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 100, undefined>]>;
+  }, undefined>;
+  readonly 'hmi.knob': v.ObjectSchema<{
+    readonly button_pressed: v.BooleanSchema<undefined>;
+    readonly button_held: v.BooleanSchema<undefined>;
+    readonly rotation_delta: v.NumberSchema<undefined>;
+  }, undefined>;
+  readonly 'management.datetime': v.ObjectSchema<{
+    readonly epoch_seconds: v.NumberSchema<undefined>;
+  }, undefined>;
+  readonly 'management.calibration': v.ObjectSchema<{
+    readonly schema_version: v.LiteralSchema<1, undefined>;
+    readonly tool_version: v.StringSchema<undefined>;
+    readonly device_id: v.StringSchema<undefined>;
+    readonly timestamp: v.StringSchema<undefined>;
+    readonly firmware_version: v.StringSchema<undefined>;
+    readonly dac: v.ArraySchema<v.ObjectSchema<{
+      readonly channel: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 31, undefined>]>;
+      readonly points: v.ArraySchema<v.ObjectSchema<{
+        readonly set: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly measured: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly reading: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, undefined>;
+      }, undefined>, undefined>;
+      readonly max_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+      readonly avg_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+    }, undefined>, undefined>;
+    readonly adc_positive: v.ArraySchema<v.ObjectSchema<{
+      readonly channel: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 31, undefined>]>;
+      readonly points: v.ArraySchema<v.ObjectSchema<{
+        readonly set: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly measured: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly reading: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, undefined>;
+      }, undefined>, undefined>;
+      readonly max_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+      readonly avg_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+    }, undefined>, undefined>;
+    readonly adc_negative: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly channel: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 31, undefined>]>;
+      readonly points: v.ArraySchema<v.ObjectSchema<{
+        readonly set: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly measured: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly reading: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, undefined>;
+      }, undefined>, undefined>;
+      readonly max_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+      readonly avg_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+    }, undefined>, undefined>, undefined>;
+    readonly dut_psu: v.ObjectSchema<{
+      readonly voltage: v.ObjectSchema<{
+        readonly points: v.ArraySchema<v.ObjectSchema<{
+          readonly set: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+          readonly measured: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+          readonly reading: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, undefined>;
+        }, undefined>, undefined>;
+        readonly max_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly avg_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+      }, undefined>;
+      readonly current: v.ObjectSchema<{
+        readonly load_ohms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, number, undefined>]>;
+        readonly points: v.ArraySchema<v.ObjectSchema<{
+          readonly set: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+          readonly measured: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+          readonly reading: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, undefined>;
+        }, undefined>, undefined>;
+        readonly max_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly avg_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+      }, undefined>;
+    }, undefined>;
+    readonly relays: v.ArraySchema<v.ObjectSchema<{
+      readonly relay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 7, undefined>]>;
+      readonly status: v.PicklistSchema<["pass", "fail"], undefined>;
+      readonly test_voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+      readonly closed_current: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+      readonly open_current: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+      readonly calibration: v.OptionalSchema<v.ObjectSchema<{
+        readonly channel: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 31, undefined>]>;
+        readonly points: v.ArraySchema<v.ObjectSchema<{
+          readonly set: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+          readonly measured: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+          readonly reading: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, undefined>;
+        }, undefined>, undefined>;
+        readonly max_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly avg_error: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+      }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly usb: v.ArraySchema<v.ObjectSchema<{
+      readonly port: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
+      readonly status: v.PicklistSchema<["pass", "fail"], undefined>;
+      readonly voltage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+      readonly current_tests: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+        readonly load_ohms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, number, undefined>]>;
+        readonly voltage_applied: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly measured_current: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly expected_current: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+        readonly error_percent: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
+      }, undefined>, undefined>, undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly 'management.calibration_state': v.ObjectSchema<{
+    readonly enabled: v.BooleanSchema<undefined>;
+    readonly loaded: v.BooleanSchema<undefined>;
+    readonly last_error: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly calibrated_at: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+  }, undefined>;
+  readonly 'management.project': v.VariantSchema<"change", [v.ObjectSchema<{
+    readonly change: v.LiteralSchema<"state_changed", undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly state: v.PicklistSchema<["created", "started", "stopped", "removed", "error"], undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly change: v.LiteralSchema<"renamed", undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly change: v.LiteralSchema<"default_changed", undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly is_default: v.BooleanSchema<undefined>;
+  }, undefined>], undefined>;
+  readonly 'management.update_status': v.ObjectSchema<{
+    readonly state: v.PicklistSchema<["idle", "installing", "failed"], undefined>;
+    readonly progress: v.NumberSchema<undefined>;
+    readonly message: v.StringSchema<undefined>;
+    readonly error: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly 'power.dut': 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>;
+  readonly 'power.usb': 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" | "~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" | "voltage" | "current">;
+    readonly "~standard": v.StandardProps<{
+      enabled: boolean;
+      voltage: number;
+      current: number;
+    }, {
+      enabled: boolean;
+      voltage: number;
+      current: number;
+    }>;
+    readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+      enabled: boolean;
+      voltage: number;
+      current: number;
+    }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>>;
+    readonly "~types"?: {
+      readonly input: {
+        enabled: boolean;
+        voltage: number;
+        current: number;
+      };
+      readonly output: {
+        enabled: boolean;
+        voltage: number;
+        current: number;
+      };
+      readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
+    } | undefined;
+  };
+  readonly 'relays.state': v.ObjectSchema<{
+    readonly state: v.PicklistSchema<["open", "closed"], undefined>;
+  }, undefined>;
+  readonly 'relays.states': v.ArraySchema<v.PicklistSchema<["open", "closed"], undefined>, undefined>;
+};
+declare const dataLessEvents: readonly ["com.reset", "gpio.reset", "hmi.clear", "hmi.reset", "power.reset", "relays.reset"];
+type EventDataSchemas = typeof eventDataSchemas;
+/** Every event `type` literal the server can emit. */
+type EventType = keyof EventDataSchemas | (typeof dataLessEvents)[number];
+type PayloadEvent = { [K in keyof EventDataSchemas]: {
+  type: K;
+  id?: number;
+  ts: number;
+  data: v.InferOutput<EventDataSchemas[K]>;
+} }[keyof EventDataSchemas];
+type DataLessEvent = {
+  type: (typeof dataLessEvents)[number];
+  id?: number;
+  ts: number;
+};
+/** A fully-typed device event for a known `type`. */
+type DeviceEvent = PayloadEvent | DataLessEvent;
+/**
+ * Shape delivered to `'*'` listeners. Forward-compatible: a newer server may emit
+ * a `type` this SDK does not model, surfaced here with an untyped `data`.
+ */
+type AnyDeviceEvent = DeviceEvent | {
+  type: string;
+  id?: number;
+  ts: number;
+  data?: unknown;
+};
+type StateListener = (connected: boolean) => void;
+/** @hideconstructor */
+declare class EventsApi {
+  private readonly host;
+  private socket;
+  private readonly listeners;
+  private readonly stateListeners;
+  private shouldReconnect;
+  private reconnectDelayMs;
+  private reconnectTimer;
+  private _connected;
+  constructor(host: string);
+  /** Whether the WebSocket is currently open. */
+  get connected(): boolean;
+  /**
+   * Open the event stream. Resolves once the socket is open, rejects on failure or
+   * after `timeout` ms. A no-op while already connected. Auto-reconnect arms only
+   * after the first successful open, so a failed initial `connect()` (e.g. old
+   * firmware without `/v0/events`) rejects without scheduling retries.
+   */
+  connect(options?: {
+    timeout?: number;
+  }): Promise<void>;
+  /** Close the stream and cancel any pending reconnect. */
+  close(): void;
+  /**
+   * Subscribe to an event `type`, or `'*'` for every event. Returns an unsubscribe
+   * function. Listeners survive reconnects and are isolated: a throwing listener
+   * does not break dispatch to the others.
+   */
+  on<T extends EventType>(type: T, listener: (event: Extract<DeviceEvent, {
+    type: T;
+  }>) => void): () => void;
+  on(type: '*', listener: (event: AnyDeviceEvent) => void): () => void;
+  /** Subscribe to connection state changes. Returns an unsubscribe function. */
+  onStateChange(listener: StateListener): () => void;
+  private openSocket;
+  private scheduleReconnect;
+  private handleMessage;
+  private emitTo;
+  private setConnected;
+}
+//#endregion
+export { EventsApi as i, DeviceEvent as n, EventType as r, AnyDeviceEvent as t };
+//# sourceMappingURL=events-PyyK1XbE.d.mts.map

package/build/events-PyyK1XbE.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-PyyK1XbE.d.mts","names":[],"sources":["../src/api/events.ts"],"mappings":";;;cA+BM,gBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCA,cAAA;AAAA,KAgBD,gBAAA,UAA0B,gBAAgB;;KAGnC,SAAA,SAAkB,gBAAA,WAA2B,cAAc;AAAA,KAElE,YAAA,iBACS,gBAAA;EACV,IAAA,EAAM,CAAA;EACN,EAAA;EACA,EAAA;EACA,IAAA,EAAM,CAAA,CAAE,WAAA,CAAY,gBAAA,CAAiB,CAAA;AAAA,UAEjC,gBAAA;AAAA,KAEH,aAAA;EAAkB,IAAA,UAAc,cAAc;EAAW,EAAA;EAAa,EAAA;AAAA;;KAG/D,WAAA,GAAc,YAAA,GAAe,aAAa;;;;;KAM1C,cAAA,GAAiB,WAAW;EACtC,IAAA;EACA,EAAA;EACA,EAAA;EACA,IAAA;AAAA;AAAA,KAIG,aAAA,IAAiB,SAAkB;;cAS3B,SAAA;EAAA,iBASkB,IAAA;EAAA,QARrB,MAAA;EAAA,iBACS,SAAA;EAAA,iBACA,cAAA;EAAA,QACT,eAAA;EAAA,QACA,gBAAA;EAAA,QACA,cAAA;EAAA,QACA,UAAA;cAEqB,IAAA;;MAGzB,SAAA;;;;;;;EAUE,OAAA,CAAQ,OAAA;IAAY,OAAA;EAAA,IAAqB,OAAA;;EAa/C,KAAA;;;;;;EAmBA,EAAA,WAAa,SAAA,EACX,IAAA,EAAM,CAAA,EACN,QAAA,GAAW,KAAA,EAAO,OAAA,CAAQ,WAAA;IAAe,IAAA,EAAM,CAAA;EAAA;EAEjD,EAAA,CAAG,IAAA,OAAW,QAAA,GAAW,KAAA,EAAO,cAAA;;EAqBhC,aAAA,CAAc,QAAA,EAAU,aAAA;EAAA,QAOhB,UAAA;EAAA,QA+DA,iBAAA;EAAA,QAiBA,aAAA;EAAA,QAgDA,MAAA;EAAA,QAcA,YAAA;AAAA"}

package/build/events.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./at1000-BAZbVgLx.cjs");exports.EventsApi=e.r;

package/build/events.d.cts

@@ -0,0 +1,2 @@
+import { i as EventsApi, n as DeviceEvent, r as EventType, t as AnyDeviceEvent } from "./events-PyyK1XbE.cjs";
+export { AnyDeviceEvent, DeviceEvent, EventType, EventsApi };

package/build/events.d.mts

@@ -0,0 +1,2 @@
+import { i as EventsApi, n as DeviceEvent, r as EventType, t as AnyDeviceEvent } from "./events-PyyK1XbE.mjs";
+export { AnyDeviceEvent, DeviceEvent, EventType, EventsApi };

package/build/events.mjs

@@ -0,0 +1 @@
+import{r as e}from"./at1000-Cxx254i3.mjs";export{e as EventsApi};

package/build/{gpio-DNrdX-QV.d.cts → gpio-CHg2nztz.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";
 
@@ -57,7 +57,7 @@ declare const partialAnalogOutputConfiguration: Omit<v.ObjectSchema<{
   }>;
   readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
     value?: number | undefined;
-  }, v.NumberIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24>>;
+  }, v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.MaxValueIssue<number, 24>>;
   readonly "~types"?: {
     readonly input: {
       value?: number | undefined;
@@ -65,7 +65,7 @@ declare const partialAnalogOutputConfiguration: Omit<v.ObjectSchema<{
     readonly output: {
       value?: number | undefined;
     };
-    readonly issue: v.NumberIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24>;
+    readonly issue: v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.MaxValueIssue<number, 24>;
   } | undefined;
 };
 type PartialAnalogOutputConfiguration = v.InferOutput<typeof partialAnalogOutputConfiguration>;
@@ -142,7 +142,7 @@ declare const partialDigitalOutputConfiguration: Omit<Omit<v.ObjectSchema<{
     vih: number;
     vol: number;
     voh: number;
-  }, v.NumberIssue | v.BooleanIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>>;
+  }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24>>;
   readonly "~types"?: {
     readonly input: {
       value: number | boolean;
@@ -158,7 +158,7 @@ declare const partialDigitalOutputConfiguration: Omit<Omit<v.ObjectSchema<{
       vol: number;
       voh: number;
     };
-    readonly issue: v.NumberIssue | v.BooleanIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>;
+    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24>;
   } | undefined;
 }, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: {
@@ -187,7 +187,7 @@ declare const partialDigitalOutputConfiguration: Omit<Omit<v.ObjectSchema<{
     vih?: number | undefined;
     vol: number;
     voh: number;
-  }, v.NumberIssue | v.BooleanIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>>;
+  }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24>>;
   readonly "~types"?: {
     readonly input: {
       value: number | boolean;
@@ -203,7 +203,7 @@ declare const partialDigitalOutputConfiguration: Omit<Omit<v.ObjectSchema<{
       vol: number;
       voh: number;
     };
-    readonly issue: v.NumberIssue | v.BooleanIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>;
+    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24>;
   } | undefined;
 };
 type PartialDigitalOutputConfiguration = v.InferInput<typeof partialDigitalOutputConfiguration>;
@@ -234,7 +234,7 @@ declare const partialOpenDrainConfiguration: Omit<v.ObjectSchema<{
     value: boolean;
     vil: number;
     vih: number;
-  }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>>;
+  }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>>;
   readonly "~types"?: {
     readonly input: {
       value: number | boolean;
@@ -246,10 +246,16 @@ declare const partialOpenDrainConfiguration: Omit<v.ObjectSchema<{
       vil: number;
       vih: number;
     };
-    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>;
+    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
   } | undefined;
 };
 type PartialOpenDrainConfiguration = v.InferOutput<typeof partialOpenDrainConfiguration>;
+declare const digitalState: v.ObjectSchema<{
+  readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
+}, undefined>;
+declare const analogState: v.ObjectSchema<{
+  readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+}, undefined>;
 declare const syncConfiguration: v.ObjectSchema<{
   readonly action: v.PicklistSchema<["release", "hold"], "Invalid sync action">;
 }, undefined>;
@@ -354,5 +360,5 @@ declare class AnalogIO {
   write(value: number): Promise<number>;
 }
 //#endregion
-export { DigitalInputConfiguration as a, OpenDrainConfiguration as c, PartialDigitalOutputConfiguration as d, PartialOpenDrainConfiguration as f, DigitalIO as i, PartialAnalogOutputConfiguration as l, AnalogInputConfiguration as n, DigitalOutputConfiguration as o, SyncConfiguration as p, AnalogOutputConfiguration as r, GpioApi as s, AnalogIO as t, PartialDigitalInputConfiguration as u };
-//# sourceMappingURL=gpio-DNrdX-QV.d.cts.map
+export { digitalInputConfiguration as _, DigitalInputConfiguration as a, openDrainConfiguration as b, OpenDrainConfiguration as c, PartialDigitalOutputConfiguration as d, PartialOpenDrainConfiguration as f, analogState as g, analogOutputConfiguration as h, DigitalIO as i, PartialAnalogOutputConfiguration as l, analogInputConfiguration as m, AnalogInputConfiguration as n, DigitalOutputConfiguration as o, SyncConfiguration as p, AnalogOutputConfiguration as r, GpioApi as s, AnalogIO as t, PartialDigitalInputConfiguration as u, digitalOutputConfiguration as v, digitalState as y };
+//# sourceMappingURL=gpio-CHg2nztz.d.cts.map

package/build/gpio-CHg2nztz.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpio-CHg2nztz.d.cts","names":[],"sources":["../src/api/gpio.ts"],"mappings":";;;;;;cASa,wBAAA,EAAwB,CAAA,CAAA,YAAA;EAAA;;;cAIxB,yBAAA,EAAyB,CAAA,CAAA,YAAA;EAAA;;;;cAKzB,yBAAA,EAAyB,CAAA,CAAA,YAAA;EAAA;;;;;cAMzB,0BAAA,EAA0B,CAAA,CAAA,YAAA;EAAA;;;;;;;;cAS1B,sBAAA,EAAsB,CAAA,CAAA,YAAA;EAAA;;;;;;KAOvB,wBAAA,GAA2B,CAAA,CAAE,WAAW,QAAQ,wBAAA;AAAA,KAChD,yBAAA,GAA4B,CAAA,CAAE,WAAW,QAAQ,yBAAA;AAAA,KACjD,yBAAA,GAA4B,CAAA,CAAE,WAAW,QAAQ,yBAAA;AAAA,KACjD,0BAAA,GAA6B,CAAA,CAAE,WAAW,QAAQ,0BAAA;AAAA,KAClD,sBAAA,GAAyB,CAAA,CAAE,WAAW,QAAQ,sBAAA;AAAA,cAEpD,gCAAA,EAAgC,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAC1B,gCAAA,GAAmC,CAAA,CAAE,WAAW,QACnD,gCAAA;AAAA,cAEH,gCAAA,EAAgC,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAC1B,gCAAA,GAAmC,CAAA,CAAE,WAAW,QACnD,gCAAA;AAAA,cAEH,iCAAA,EAAiC,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI3B,iCAAA,GAAoC,CAAA,CAAE,UAAU,QACnD,iCAAA;AAAA,cAEH,6BAAA,EAA6B,IAAA,CAAA,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACvB,6BAAA,GAAgC,CAAA,CAAE,WAAW,QAAQ,6BAAA;AAAA,cAEpD,YAAA,EAAY,CAAA,CAAA,YAAA;EAAA;;cACZ,WAAA,EAAW,CAAA,CAAA,YAAA;EAAA;;cAElB,iBAAA,EAAiB,CAAA,CAAA,YAAA;EAAA,iBAAmC,CAAA,CAAA,cAAA;AAAA;AAAA,KAC9C,iBAAA,GAAoB,CAAA,CAAE,WAAW,QAAQ,iBAAA;;cAGxC,OAAA;EAAA,iBAGkB,KAAA;EAAA,QAFrB,KAAA;cAEqB,KAAA,EAAO,OAAA,EAAS,IAAA,EAAM,WAAA;EAhCzC;;;EAuCV,KAAA,IAAS,OAAA;EAvC6B;;;;AAA8C;EAgDpF,OAAA,CAAQ,EAAA,WAAa,SAAA;EA/Ce;;;;;EAgEpC,MAAA,CAAO,EAAA,WAAa,QAAA;EAhEkE;AAAA;AACxF;;EA+EE,IAAA,IAAQ,OAAA,CAAQ,iBAAA;EA/EgC;;;;;AAA8B;AAAE;EA8FhF,OAAA,IAAW,OAAA,CAAQ,iBAAA;AAAA;;cAUR,SAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;;;EAO7D,eAAA,CAAgB,MAAA,EAAQ,gCAAA,GAAmC,OAAA,CAAQ,yBAAA;;;;;;EAgBnE,gBAAA,CAAiB,MAAA,EAAQ,iCAAA,GAAoC,OAAA,CAAQ,0BAAA;;;;;EAwB/D,IAAA,IAAQ,OAAA;;;;;;EASR,KAAA,CAAM,KAAA,qBAA0B,OAAA;;;;;;EActC,oBAAA,CAAqB,MAAA,EAAQ,6BAAA,GAAgC,OAAA,CAAQ,sBAAA;AAAA;;cAa1D,QAAA;EAAA,iBACkB,KAAA;EAAA,SAAgC,EAAA;cAAhC,KAAA,EAAO,OAAA,EAAyB,EAAA;;;;;;EAO7D,eAAA,IAAmB,OAAA,CAAQ,wBAAA;;;;;;EAa3B,gBAAA,CAAiB,KAAA,EAAO,iBAAA,GAAoB,OAAA,CAAQ,yBAAA;;;;;EAe9C,IAAA,IAAQ,OAAA;;;;;;EASR,KAAA,CAAM,KAAA,WAAgB,OAAA;AAAA"}

package/build/{gpio-DchxrXWK.d.mts → gpio-CbGcoT9b.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";
 
@@ -57,7 +57,7 @@ declare const partialAnalogOutputConfiguration: Omit<v.ObjectSchema<{
   }>;
   readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
     value?: number | undefined;
-  }, v.NumberIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24>>;
+  }, v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.MaxValueIssue<number, 24>>;
   readonly "~types"?: {
     readonly input: {
       value?: number | undefined;
@@ -65,7 +65,7 @@ declare const partialAnalogOutputConfiguration: Omit<v.ObjectSchema<{
     readonly output: {
       value?: number | undefined;
     };
-    readonly issue: v.NumberIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24>;
+    readonly issue: v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.MaxValueIssue<number, 24>;
   } | undefined;
 };
 type PartialAnalogOutputConfiguration = v.InferOutput<typeof partialAnalogOutputConfiguration>;
@@ -142,7 +142,7 @@ declare const partialDigitalOutputConfiguration: Omit<Omit<v.ObjectSchema<{
     vih: number;
     vol: number;
     voh: number;
-  }, v.NumberIssue | v.BooleanIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>>;
+  }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24>>;
   readonly "~types"?: {
     readonly input: {
       value: number | boolean;
@@ -158,7 +158,7 @@ declare const partialDigitalOutputConfiguration: Omit<Omit<v.ObjectSchema<{
       vol: number;
       voh: number;
     };
-    readonly issue: v.NumberIssue | v.BooleanIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>;
+    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24>;
   } | undefined;
 }, "~standard" | "~types" | "~run" | "entries"> & {
   readonly entries: {
@@ -187,7 +187,7 @@ declare const partialDigitalOutputConfiguration: Omit<Omit<v.ObjectSchema<{
     vih?: number | undefined;
     vol: number;
     voh: number;
-  }, v.NumberIssue | v.BooleanIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>>;
+  }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24>>;
   readonly "~types"?: {
     readonly input: {
       value: number | boolean;
@@ -203,7 +203,7 @@ declare const partialDigitalOutputConfiguration: Omit<Omit<v.ObjectSchema<{
       vol: number;
       voh: number;
     };
-    readonly issue: v.NumberIssue | v.BooleanIssue | v.MinValueIssue<number, 0> | v.ObjectIssue | v.MaxValueIssue<number, 24> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>;
+    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24>;
   } | undefined;
 };
 type PartialDigitalOutputConfiguration = v.InferInput<typeof partialDigitalOutputConfiguration>;
@@ -234,7 +234,7 @@ declare const partialOpenDrainConfiguration: Omit<v.ObjectSchema<{
     value: boolean;
     vil: number;
     vih: number;
-  }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>>;
+  }, v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>>;
   readonly "~types"?: {
     readonly input: {
       value: number | boolean;
@@ -246,10 +246,16 @@ declare const partialOpenDrainConfiguration: Omit<v.ObjectSchema<{
       vil: number;
       vih: number;
     };
-    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.UnionIssue<v.NumberIssue | v.BooleanIssue>;
+    readonly issue: v.NumberIssue | v.BooleanIssue | v.ObjectIssue | v.UnionIssue<v.NumberIssue | v.BooleanIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>;
   } | undefined;
 };
 type PartialOpenDrainConfiguration = v.InferOutput<typeof partialOpenDrainConfiguration>;
+declare const digitalState: v.ObjectSchema<{
+  readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
+}, undefined>;
+declare const analogState: v.ObjectSchema<{
+  readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+}, undefined>;
 declare const syncConfiguration: v.ObjectSchema<{
   readonly action: v.PicklistSchema<["release", "hold"], "Invalid sync action">;
 }, undefined>;
@@ -354,5 +360,5 @@ declare class AnalogIO {
   write(value: number): Promise<number>;
 }
 //#endregion
-export { DigitalInputConfiguration as a, OpenDrainConfiguration as c, PartialDigitalOutputConfiguration as d, PartialOpenDrainConfiguration as f, DigitalIO as i, PartialAnalogOutputConfiguration as l, AnalogInputConfiguration as n, DigitalOutputConfiguration as o, SyncConfiguration as p, AnalogOutputConfiguration as r, GpioApi as s, AnalogIO as t, PartialDigitalInputConfiguration as u };
-//# sourceMappingURL=gpio-DchxrXWK.d.mts.map
+export { digitalInputConfiguration as _, DigitalInputConfiguration as a, openDrainConfiguration as b, OpenDrainConfiguration as c, PartialDigitalOutputConfiguration as d, PartialOpenDrainConfiguration as f, analogState as g, analogOutputConfiguration as h, DigitalIO as i, PartialAnalogOutputConfiguration as l, analogInputConfiguration as m, AnalogInputConfiguration as n, DigitalOutputConfiguration as o, SyncConfiguration as p, AnalogOutputConfiguration as r, GpioApi as s, AnalogIO as t, PartialDigitalInputConfiguration as u, digitalOutputConfiguration as v, digitalState as y };
+//# sourceMappingURL=gpio-CbGcoT9b.d.mts.map

package/build/gpio-CbGcoT9b.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpio-CbGcoT9b.d.mts","names":[],"sources":["../src/api/gpio.ts"],"mappings":"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"}

package/build/gpio.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.picklist([`release`,`hold`],`Invalid sync action`),i=n.object({mode:n.literal(`analog`),direction:n.literal(`input`)}),a=n.object({mode:n.literal(`analog`),direction:n.literal(`output`),value:n.optional(t.n)}),o=n.object({mode:n.literal(`digital`),direction:n.literal(`input`),vil:t.t,vih:t.t}),s=n.object({mode:n.literal(`digital`),direction:n.literal(`output`),value:t.r,vol:t.n,voh:t.n,vil:t.t,vih:t.t}),c=n.object({mode:n.literal(`digital`),direction:n.literal(`open_drain`),value:t.r,vil:t.t,vih:t.t});n.omit(a,[`direction`,`mode`]),n.omit(o,[`direction`,`mode`]);const l=n.partial(n.omit(s,[`direction`,`mode`]),[`vih`,`vil`]);n.omit(c,[`direction`,`mode`]);const u=n.object({value:t.r}),d=n.object({value:t.t}),f=n.object({action:r});var p=class{fetch;count;constructor(e,t){this.fetch=e,this.count=t.capabilities.io.count}reset(){return this.fetch(`/gpio/reset`,{method:`POST`,parseResponse:()=>{}})}digital(e){if(e<0||e>=this.count)throw Error(`Invalid GPIO pin ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a pin number between 0 and ${this.count-1}\n    Path: /gpio/${e}`);return new m(this.fetch,e)}analog(e){if(e<0||e>=this.count)throw Error(`Invalid GPIO pin ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a pin number between 0 and ${this.count-1}\n    Path: /gpio/${e}`);return new h(this.fetch,e)}hold(){return this.fetch(`/gpio/sync`,{method:`POST`,body:{action:`hold`},schema:f})}release(){return this.fetch(`/gpio/sync`,{method:`POST`,body:{action:`release`},schema:f})}},m=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}configure_input(e){return this.fetch(`/gpio/${this.id}/config`,{method:`PATCH`,body:n.parse(o,{...e,mode:`digital`,direction:`input`}),schema:o})}configure_output(e){e=n.parse(l,e);let t={mode:`digital`,direction:`output`,value:e.value,vol:e.vol,voh:e.voh,vil:e.vil??e.vol+(e.voh-e.vol)/4,vih:e.vih??e.voh-(e.voh-e.vol)/4};return this.fetch(`/gpio/${this.id}/config`,{method:`PATCH`,body:n.parse(s,t),schema:s})}async read(){return(await this.fetch(`/gpio/${this.id}/state`,{schema:u})).value}async write(e){return(await this.fetch(`/gpio/${this.id}/state`,{method:`PUT`,body:n.parse(u,{value:e}),schema:u})).value}configure_open_drain(e){return this.fetch(`/gpio/${this.id}/config`,{method:`PATCH`,body:n.parse(c,{...e,mode:`digital`,direction:`open_drain`}),schema:c})}},h=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}configure_input(){return this.fetch(`/gpio/${this.id}/config`,{method:`PATCH`,body:{mode:`analog`,direction:`input`},schema:i})}configure_output(e){return this.fetch(`/gpio/${this.id}/config`,{method:`PATCH`,body:n.parse(a,{value:e,mode:`analog`,direction:`output`}),schema:a})}async read(){return(await this.fetch(`/gpio/${this.id}/state`,{schema:d})).value}async write(e){return(await this.fetch(`/gpio/${this.id}/state`,{method:`PUT`,body:{value:e},schema:d})).value}};exports.AnalogIO=h,exports.DigitalIO=m,exports.GpioApi=p;
+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.picklist([`release`,`hold`],`Invalid sync action`),i=n.object({mode:n.literal(`analog`),direction:n.literal(`input`)}),a=n.object({mode:n.literal(`analog`),direction:n.literal(`output`),value:n.optional(t.n)}),o=n.object({mode:n.literal(`digital`),direction:n.literal(`input`),vil:t.t,vih:t.t}),s=n.object({mode:n.literal(`digital`),direction:n.literal(`output`),value:t.r,vol:t.n,voh:t.n,vil:t.t,vih:t.t}),c=n.object({mode:n.literal(`digital`),direction:n.literal(`open_drain`),value:t.r,vil:t.t,vih:t.t});n.omit(a,[`direction`,`mode`]),n.omit(o,[`direction`,`mode`]);const l=n.partial(n.omit(s,[`direction`,`mode`]),[`vih`,`vil`]);n.omit(c,[`direction`,`mode`]);const u=n.object({value:t.r}),d=n.object({value:t.t}),f=n.object({action:r});var p=class{fetch;count;constructor(e,t){this.fetch=e,this.count=t.capabilities.io.count}reset(){return this.fetch(`/gpio/reset`,{method:`POST`,parseResponse:()=>{}})}digital(e){if(e<0||e>=this.count)throw Error(`Invalid GPIO pin ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a pin number between 0 and ${this.count-1}\n    Path: /gpio/${e}`);return new m(this.fetch,e)}analog(e){if(e<0||e>=this.count)throw Error(`Invalid GPIO pin ${e} (RESOURCE_NOT_FOUND)\n    Suggestion: Use a pin number between 0 and ${this.count-1}\n    Path: /gpio/${e}`);return new h(this.fetch,e)}hold(){return this.fetch(`/gpio/sync`,{method:`POST`,body:{action:`hold`},schema:f})}release(){return this.fetch(`/gpio/sync`,{method:`POST`,body:{action:`release`},schema:f})}},m=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}configure_input(e){return this.fetch(`/gpio/${this.id}/config`,{method:`PATCH`,body:n.parse(o,{...e,mode:`digital`,direction:`input`}),schema:o})}configure_output(e){e=n.parse(l,e);let t={mode:`digital`,direction:`output`,value:e.value,vol:e.vol,voh:e.voh,vil:e.vil??e.vol+(e.voh-e.vol)/4,vih:e.vih??e.voh-(e.voh-e.vol)/4};return this.fetch(`/gpio/${this.id}/config`,{method:`PATCH`,body:n.parse(s,t),schema:s})}async read(){return(await this.fetch(`/gpio/${this.id}/state`,{schema:u})).value}async write(e){return(await this.fetch(`/gpio/${this.id}/state`,{method:`PUT`,body:n.parse(u,{value:e}),schema:u})).value}configure_open_drain(e){return this.fetch(`/gpio/${this.id}/config`,{method:`PATCH`,body:n.parse(c,{...e,mode:`digital`,direction:`open_drain`}),schema:c})}},h=class{fetch;id;constructor(e,t){this.fetch=e,this.id=t}configure_input(){return this.fetch(`/gpio/${this.id}/config`,{method:`PATCH`,body:{mode:`analog`,direction:`input`},schema:i})}configure_output(e){return this.fetch(`/gpio/${this.id}/config`,{method:`PATCH`,body:n.parse(a,{value:e,mode:`analog`,direction:`output`}),schema:a})}async read(){return(await this.fetch(`/gpio/${this.id}/state`,{schema:d})).value}async write(e){return(await this.fetch(`/gpio/${this.id}/state`,{method:`PUT`,body:{value:e},schema:d})).value}};exports.AnalogIO=h,exports.DigitalIO=m,exports.GpioApi=p,exports.analogInputConfiguration=i,exports.analogOutputConfiguration=a,exports.analogState=d,exports.digitalInputConfiguration=o,exports.digitalOutputConfiguration=s,exports.digitalState=u,exports.openDrainConfiguration=c;
 //# sourceMappingURL=gpio.cjs.map