@ikalogic/at1000 0.2.2 → 0.3.0

package/build/events-PyyK1XbE.d.cts

@@ -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.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events-PyyK1XbE.d.cts","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"}