@ikalogic/at1000 0.2.2 → 0.4.0

package/build/events-CBVQfojK.d.mts

@@ -0,0 +1,359 @@
+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>, "~types" | "~run" | "~standard" | "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.BooleanIssue | v.NumberIssue | 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.BooleanIssue | v.NumberIssue | 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>;
+  readonly 'session.state': v.ObjectSchema<{
+    readonly active: v.BooleanSchema<undefined>;
+    readonly kind: v.OptionalSchema<v.PicklistSchema<["remote", "project"], undefined>, undefined>;
+    readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly project: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly since: v.OptionalSchema<v.NumberSchema<undefined>, 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;
+  private connectPromise;
+  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-CBVQfojK.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events-CBVQfojK.d.mts","names":[],"sources":["../src/api/events.ts"],"mappings":";;;cAiCM,gBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuCA,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,iBAUkB,IAAA;EAAA,QATrB,MAAA;EAAA,iBACS,SAAA;EAAA,iBACA,cAAA;EAAA,QACT,eAAA;EAAA,QACA,gBAAA;EAAA,QACA,cAAA;EAAA,QACA,UAAA;EAAA,QACA,cAAA;cAEqB,IAAA;;MAGzB,SAAA;;;;;;;EAUE,OAAA,CAAQ,OAAA;IAAY,OAAA;EAAA,IAAqB,OAAA;;EAsB/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-B_udjy0I.cjs");exports.EventsApi=e.o;

package/build/events.d.cts

@@ -0,0 +1,2 @@
+import { i as EventsApi, n as DeviceEvent, r as EventType, t as AnyDeviceEvent } from "./events-CBVQfojK.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-CBVQfojK.mjs";
+export { AnyDeviceEvent, DeviceEvent, EventType, EventsApi };

package/build/events.mjs

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

package/build/{gpio-DNrdX-QV.d.cts → gpio-BuvDysYa.d.cts}

@@ -1,5 +1,5 @@
 import { t as AnalogOutputLevel } from "./common-BY1vXz1l.cjs";
-import { l as Information } from "./management-C0iQha23.cjs";
+import { Information } from "./management.cjs";
 import { UpFetch } from "up-fetch";
 import * as v from "valibot";
 
@@ -44,7 +44,7 @@ declare const partialAnalogOutputConfiguration: Omit<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>, "~standard" | "~types" | "~run" | "entries"> & {
+}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
   readonly entries: Omit<{
     readonly mode: v.LiteralSchema<"analog", undefined>;
     readonly direction: v.LiteralSchema<"output", undefined>;
@@ -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>;
@@ -74,7 +74,7 @@ declare const partialDigitalInputConfiguration: Omit<v.ObjectSchema<{
   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>, "~standard" | "~types" | "~run" | "entries"> & {
+}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
   readonly entries: Omit<{
     readonly mode: v.LiteralSchema<"digital", undefined>;
     readonly direction: v.LiteralSchema<"input", undefined>;
@@ -113,7 +113,7 @@ declare const partialDigitalOutputConfiguration: Omit<Omit<v.ObjectSchema<{
   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>, "~standard" | "~types" | "~run" | "entries"> & {
+}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
   readonly entries: Omit<{
     readonly mode: v.LiteralSchema<"digital", undefined>;
     readonly direction: v.LiteralSchema<"output", undefined>;
@@ -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.BooleanIssue | v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.BooleanIssue | v.NumberIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24>>;
   readonly "~types"?: {
     readonly input: {
       value: number | boolean;
@@ -158,9 +158,9 @@ 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.BooleanIssue | v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.BooleanIssue | v.NumberIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24>;
   } | undefined;
-}, "~standard" | "~types" | "~run" | "entries"> & {
+}, "~types" | "~run" | "~standard" | "entries"> & {
   readonly entries: {
     readonly value: v.SchemaWithPipe<readonly [v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.ToBooleanAction<number | boolean>]>;
     readonly vil: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>, undefined>;
@@ -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.BooleanIssue | v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.BooleanIssue | v.NumberIssue> | 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.BooleanIssue | v.NumberIssue | v.ObjectIssue | v.MinValueIssue<number, 0> | v.UnionIssue<v.BooleanIssue | v.NumberIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25> | v.MaxValueIssue<number, 24>;
   } | undefined;
 };
 type PartialDigitalOutputConfiguration = v.InferInput<typeof partialDigitalOutputConfiguration>;
@@ -213,7 +213,7 @@ declare const partialOpenDrainConfiguration: Omit<v.ObjectSchema<{
   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>, "~standard" | "~types" | "~run" | "entries"> & {
+}, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
   readonly entries: Omit<{
     readonly mode: v.LiteralSchema<"digital", undefined>;
     readonly direction: v.LiteralSchema<"open_drain", undefined>;
@@ -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.BooleanIssue | v.NumberIssue | v.ObjectIssue | v.UnionIssue<v.BooleanIssue | v.NumberIssue> | v.MinValueIssue<number, -25> | v.MaxValueIssue<number, 25>>;
   readonly "~types"?: {
     readonly input: {
       value: number | boolean;
@@ -246,14 +246,52 @@ 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.BooleanIssue | v.NumberIssue | v.ObjectIssue | v.UnionIssue<v.BooleanIssue | v.NumberIssue> | 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>;
 type SyncConfiguration = v.InferOutput<typeof syncConfiguration>;
+declare const syncState: v.ObjectSchema<{
+  readonly hold_state: v.PicklistSchema<["held", "released"], undefined>;
+}, undefined>;
+type SyncState = v.InferOutput<typeof syncState>;
+declare const gpioConfiguration: v.UnionSchema<[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>, 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<"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<"analog", undefined>;
+  readonly direction: v.LiteralSchema<"input", undefined>;
+}, undefined>], undefined>;
+type GpioConfiguration = v.InferOutput<typeof gpioConfiguration>;
 /** @hideconstructor */
 declare class GpioApi {
   private readonly fetch;
@@ -288,6 +326,17 @@ declare class GpioApi {
    * @returns The applied sync state.
    */
   release(): Promise<SyncConfiguration>;
+  /**
+   * Reads back the current configuration of a specific IO pin.
+   * @param io The IO pin id.
+   * @returns The pin's current configuration.
+   */
+  read_config(io: number): Promise<GpioConfiguration>;
+  /**
+   * Reads the current hold state of all GPIO pins.
+   * @returns The current sync state.
+   */
+  read_sync(): Promise<SyncState>;
 }
 /** @hideconstructor */
 declare class DigitalIO {
@@ -354,5 +403,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 { openDrainConfiguration as C, gpioConfiguration as S, analogOutputConfiguration as _, DigitalInputConfiguration as a, digitalOutputConfiguration as b, GpioConfiguration as c, PartialDigitalInputConfiguration as d, PartialDigitalOutputConfiguration as f, analogInputConfiguration as g, SyncState as h, DigitalIO as i, OpenDrainConfiguration as l, SyncConfiguration as m, AnalogInputConfiguration as n, DigitalOutputConfiguration as o, PartialOpenDrainConfiguration as p, AnalogOutputConfiguration as r, GpioApi as s, AnalogIO as t, PartialAnalogOutputConfiguration as u, analogState as v, syncState as w, digitalState as x, digitalInputConfiguration as y };
+//# sourceMappingURL=gpio-BuvDysYa.d.cts.map

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

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