@ikalogic/at1000 0.5.2 → 0.7.0

package/build/gpio-5-tRkdTW.d.mts

@@ -0,0 +1,712 @@
+import { t as AnalogOutputLevel } from "./common-Cv6nZZS9.mjs";
+import { Information } from "./management.mjs";
+import { UpFetch } from "up-fetch";
+import * as v from "valibot";
+//#region src/api/gpio.d.ts
+declare const analogInputConfiguration: v.ObjectSchema<{
+  readonly mode: v.LiteralSchema<"analog", undefined>;
+  readonly direction: v.LiteralSchema<"input", undefined>;
+}, undefined>;
+declare const analogOutputConfiguration: 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>;
+/**
+ * Input thresholds `vil` and `vih` are in [-25, 25] V, inclusive.
+ */
+declare const digitalInputConfiguration: 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>;
+/**
+ * Readback thresholds `vil` and `vih` are in [-25, 25] V, inclusive.
+ * Output levels `vol` and `voh` are in [0, 24] V, inclusive.
+ */
+declare const digitalOutputConfiguration: 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>;
+/**
+ * Readback thresholds `vil` and `vih` are in [-25, 25] V, inclusive.
+ */
+declare const openDrainConfiguration: 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>;
+type AnalogInputConfiguration = v.InferOutput<typeof analogInputConfiguration>;
+type AnalogOutputConfiguration = v.InferOutput<typeof analogOutputConfiguration>;
+type DigitalInputConfiguration = v.InferOutput<typeof digitalInputConfiguration>;
+type DigitalOutputConfiguration = v.InferOutput<typeof digitalOutputConfiguration>;
+type OpenDrainConfiguration = v.InferOutput<typeof openDrainConfiguration>;
+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>, "entries" | "~run" | "~standard" | "~types"> & {
+  readonly entries: Omit<{
+    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>;
+  }, "direction" | "mode">;
+  readonly "~standard": v.StandardProps<{
+    value?: number | undefined;
+  }, {
+    value?: number | undefined;
+  }>;
+  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+    value?: number | undefined;
+  }, v.MaxValueIssue<number, 24> | v.MinValueIssue<number, 0> | v.NumberIssue | v.ObjectIssue>;
+  readonly "~types"?: {
+    readonly input: {
+      value?: number | undefined;
+    };
+    readonly output: {
+      value?: number | undefined;
+    };
+    readonly issue: v.MaxValueIssue<number, 24> | v.MinValueIssue<number, 0> | v.NumberIssue | v.ObjectIssue;
+  } | undefined;
+};
+type PartialAnalogOutputConfiguration = v.InferOutput<typeof partialAnalogOutputConfiguration>;
+declare const partialDigitalInputConfiguration: Omit<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>, "entries" | "~run" | "~standard" | "~types"> & {
+  readonly entries: Omit<{
+    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>]>;
+  }, "direction" | "mode">;
+  readonly "~standard": v.StandardProps<{
+    vil: number;
+    vih: number;
+  }, {
+    vil: number;
+    vih: number;
+  }>;
+  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+    vil: number;
+    vih: number;
+  }, v.MaxValueIssue<number, 25> | v.MinValueIssue<number, -25> | v.NumberIssue | v.ObjectIssue>;
+  readonly "~types"?: {
+    readonly input: {
+      vil: number;
+      vih: number;
+    };
+    readonly output: {
+      vil: number;
+      vih: number;
+    };
+    readonly issue: v.MaxValueIssue<number, 25> | v.MinValueIssue<number, -25> | v.NumberIssue | v.ObjectIssue;
+  } | undefined;
+};
+type PartialDigitalInputConfiguration = v.InferOutput<typeof partialDigitalInputConfiguration>;
+declare const partialDigitalOutputConfiguration: Omit<Omit<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>, "entries" | "~run" | "~standard" | "~types"> & {
+  readonly entries: Omit<{
+    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>]>;
+  }, "direction" | "mode">;
+  readonly "~standard": v.StandardProps<{
+    value: number | boolean;
+    vol: number;
+    voh: number;
+    vil: number;
+    vih: number;
+  }, {
+    value: boolean;
+    vol: number;
+    voh: number;
+    vil: number;
+    vih: number;
+  }>;
+  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+    value: boolean;
+    vol: number;
+    voh: number;
+    vil: number;
+    vih: number;
+  }, v.BooleanIssue | v.MaxValueIssue<number, 24> | v.MaxValueIssue<number, 25> | v.MinValueIssue<number, -25> | v.MinValueIssue<number, 0> | v.NumberIssue | v.ObjectIssue | v.UnionIssue<v.BooleanIssue | v.NumberIssue>>;
+  readonly "~types"?: {
+    readonly input: {
+      value: number | boolean;
+      vol: number;
+      voh: number;
+      vil: number;
+      vih: number;
+    };
+    readonly output: {
+      value: boolean;
+      vol: number;
+      voh: number;
+      vil: number;
+      vih: number;
+    };
+    readonly issue: v.BooleanIssue | v.MaxValueIssue<number, 24> | v.MaxValueIssue<number, 25> | v.MinValueIssue<number, -25> | v.MinValueIssue<number, 0> | v.NumberIssue | v.ObjectIssue | v.UnionIssue<v.BooleanIssue | v.NumberIssue>;
+  } | undefined;
+}, "entries" | "~run" | "~standard" | "~types"> & {
+  readonly entries: {
+    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.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>, undefined>;
+    readonly vih: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>, undefined>;
+  };
+  readonly "~standard": v.StandardProps<{
+    value: number | boolean;
+    vol: number;
+    voh: number;
+    vil?: number | undefined;
+    vih?: number | undefined;
+  }, {
+    value: boolean;
+    vol: number;
+    voh: number;
+    vil?: number | undefined;
+    vih?: number | undefined;
+  }>;
+  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+    value: boolean;
+    vol: number;
+    voh: number;
+    vil?: number | undefined;
+    vih?: number | undefined;
+  }, v.BooleanIssue | v.MaxValueIssue<number, 24> | v.MaxValueIssue<number, 25> | v.MinValueIssue<number, -25> | v.MinValueIssue<number, 0> | v.NumberIssue | v.ObjectIssue | v.UnionIssue<v.BooleanIssue | v.NumberIssue>>;
+  readonly "~types"?: {
+    readonly input: {
+      value: number | boolean;
+      vol: number;
+      voh: number;
+      vil?: number | undefined;
+      vih?: number | undefined;
+    };
+    readonly output: {
+      value: boolean;
+      vol: number;
+      voh: number;
+      vil?: number | undefined;
+      vih?: number | undefined;
+    };
+    readonly issue: v.BooleanIssue | v.MaxValueIssue<number, 24> | v.MaxValueIssue<number, 25> | v.MinValueIssue<number, -25> | v.MinValueIssue<number, 0> | v.NumberIssue | v.ObjectIssue | v.UnionIssue<v.BooleanIssue | v.NumberIssue>;
+  } | undefined;
+};
+type PartialDigitalOutputConfiguration = v.InferInput<typeof partialDigitalOutputConfiguration>;
+declare const partialOpenDrainConfiguration: Omit<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>, "entries" | "~run" | "~standard" | "~types"> & {
+  readonly entries: Omit<{
+    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>]>;
+  }, "direction" | "mode">;
+  readonly "~standard": v.StandardProps<{
+    value: number | boolean;
+    vil: number;
+    vih: number;
+  }, {
+    value: boolean;
+    vil: number;
+    vih: number;
+  }>;
+  readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+    value: boolean;
+    vil: number;
+    vih: number;
+  }, v.BooleanIssue | v.MaxValueIssue<number, 25> | v.MinValueIssue<number, -25> | v.NumberIssue | v.ObjectIssue | v.UnionIssue<v.BooleanIssue | v.NumberIssue>>;
+  readonly "~types"?: {
+    readonly input: {
+      value: number | boolean;
+      vil: number;
+      vih: number;
+    };
+    readonly output: {
+      value: boolean;
+      vil: number;
+      vih: number;
+    };
+    readonly issue: v.BooleanIssue | v.MaxValueIssue<number, 25> | v.MinValueIssue<number, -25> | v.NumberIssue | v.ObjectIssue | v.UnionIssue<v.BooleanIssue | v.NumberIssue>;
+  } | 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 sequenceValue: v.UnionSchema<[v.BooleanSchema<undefined>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>], undefined>;
+declare const sequenceExpect: v.UnionSchema<[v.BooleanSchema<undefined>, v.ObjectSchema<{
+  readonly min: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+  readonly max: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+}, undefined>], undefined>;
+declare const sequenceCommand: v.VariantSchema<"op", [v.ObjectSchema<{
+  readonly op: v.LiteralSchema<"read", undefined>;
+  readonly io: v.UnionSchema<[v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 31, undefined>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 31, undefined>]>, undefined>, v.MinLengthAction<number[], 1, undefined>]>], undefined>;
+  readonly repeat: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+  readonly delay: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, number, undefined>]>, undefined>;
+  readonly expect: v.OptionalSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.ObjectSchema<{
+    readonly min: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+    readonly max: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>;
+  }, undefined>], undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly op: v.LiteralSchema<"write", undefined>;
+  readonly io: v.UnionSchema<[v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 31, undefined>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 31, undefined>]>, undefined>, v.MinLengthAction<number[], 1, undefined>]>], undefined>;
+  readonly value: v.UnionSchema<[v.UnionSchema<[v.BooleanSchema<undefined>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>], undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>], undefined>, undefined>, v.MinLengthAction<(number | boolean)[], 1, undefined>]>], undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly op: v.LiteralSchema<"wait_voltage", undefined>;
+  readonly io: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 31, undefined>]>;
+  readonly min: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>, undefined>;
+  readonly max: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, -25, undefined>, v.MaxValueAction<number, 25, undefined>]>, undefined>;
+  readonly timeout: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, number, undefined>]>, undefined>;
+  readonly stable_for: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, number, undefined>]>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly op: v.LiteralSchema<"wait_level", undefined>;
+  readonly io: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 31, undefined>]>;
+  readonly level: v.PicklistSchema<["low", "high"], "Invalid level">;
+  readonly timeout: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, number, undefined>]>, undefined>;
+  readonly stable_for: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, number, undefined>]>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly op: v.LiteralSchema<"delay", undefined>;
+  readonly duration: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, number, undefined>]>;
+}, undefined>, v.ObjectSchema<{
+  readonly op: v.LiteralSchema<"hold", undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly op: v.LiteralSchema<"release", undefined>;
+}, undefined>], undefined>;
+declare const sequenceSample: v.ObjectSchema<{
+  readonly io: v.NumberSchema<undefined>;
+  readonly value: v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>;
+  readonly elapsed: v.NumberSchema<undefined>;
+}, undefined>;
+declare const sequenceStep: v.ObjectSchema<{
+  readonly op: v.PicklistSchema<["read", "write", "wait_voltage", "wait_level", "delay", "hold", "release"], undefined>;
+  readonly io: v.OptionalSchema<v.UnionSchema<[v.NumberSchema<undefined>, v.ArraySchema<v.NumberSchema<undefined>, undefined>], undefined>, undefined>;
+  readonly value: v.OptionalSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+  readonly samples: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+    readonly io: v.NumberSchema<undefined>;
+    readonly value: v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>;
+    readonly elapsed: v.NumberSchema<undefined>;
+  }, undefined>, undefined>, undefined>;
+  readonly elapsed: v.NumberSchema<undefined>;
+}, undefined>;
+declare const sequenceReport: v.ObjectSchema<{
+  readonly elapsed: v.NumberSchema<undefined>;
+  readonly results: v.ArraySchema<v.ObjectSchema<{
+    readonly op: v.PicklistSchema<["read", "write", "wait_voltage", "wait_level", "delay", "hold", "release"], undefined>;
+    readonly io: v.OptionalSchema<v.UnionSchema<[v.NumberSchema<undefined>, v.ArraySchema<v.NumberSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly value: v.OptionalSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly samples: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly io: v.NumberSchema<undefined>;
+      readonly value: v.UnionSchema<[v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>;
+      readonly elapsed: v.NumberSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly elapsed: v.NumberSchema<undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+type GpioSequenceCommand = v.InferOutput<typeof sequenceCommand>;
+type GpioSequenceSample = v.InferOutput<typeof sequenceSample>;
+/**
+ * Result of one command.
+ *
+ * `value` carries a single-valued step — an ordinary read of one pin with no repeat, or
+ * a write of one pin — while `samples` carries a step that covered several pins or
+ * repeated: the readings of a `read`, or the values a `write` applied.
+ */
+type GpioSequenceStep = v.InferOutput<typeof sequenceStep>;
+type SequenceWireReport = v.InferOutput<typeof sequenceReport>;
+type SequenceKind = 'scalar' | 'collection' | 'control';
+type SequenceDescriptor<Op extends GpioSequenceCommand['op'] = GpioSequenceCommand['op'], Kind extends SequenceKind = SequenceKind> = {
+  op: Op;
+  kind: Kind;
+};
+type SequenceMetadata<Op> = {
+  name: string;
+  index: number;
+  op: Op;
+};
+type SequenceAttempt<Op> = SequenceMetadata<Op> & {
+  elapsed: number;
+};
+type SequenceScalar<Op> = SequenceAttempt<Op> & {
+  kind: 'scalar';
+  io: number | number[];
+  value: boolean | number;
+};
+type SequenceCollection<Op> = SequenceAttempt<Op> & {
+  kind: 'collection';
+  io: number | number[];
+  samples: GpioSequenceSample[];
+};
+type SequenceControl<Op> = SequenceAttempt<Op> & {
+  kind: 'control';
+};
+type SequenceResultForKind<Op, Kind> = Kind extends 'scalar' ? SequenceScalar<Op> : Kind extends 'collection' ? SequenceCollection<Op> : SequenceControl<Op>;
+type SequenceResult<Descriptor> = Descriptor extends SequenceDescriptor<infer Op, infer Kind> ? SequenceResultForKind<Op, Kind> : never;
+type SequenceDescriptors = SequenceDescriptor<'read' | 'write', 'scalar' | 'collection'> | SequenceDescriptor<'wait_voltage' | 'wait_level', 'scalar'> | SequenceDescriptor<'hold' | 'release' | 'delay', 'control'>;
+type GpioSequenceNamedResult = SequenceResult<SequenceDescriptors>;
+type SequenceNamed<Names> = { readonly [Name in keyof Names]: SequenceResult<Names[Name]>; };
+type SequenceAssociation = {
+  name: string;
+  index: number;
+  command: GpioSequenceCommand;
+};
+/** Raw results remain in command order. Names are local to this run. */
+declare class GpioSequenceReport<Names = {}> {
+  #private;
+  readonly elapsed: number;
+  readonly results: GpioSequenceStep[];
+  readonly named: SequenceNamed<Names>;
+  /** Constructing a bare wire report does not restore command names. */
+  constructor(wire: SequenceWireReport, associations?: readonly SequenceAssociation[]);
+  get(name: string): GpioSequenceNamedResult | undefined;
+  toJSON(): SequenceWireReport;
+}
+type SequenceReadRepeat<Options> = Options extends GpioSequenceReadOptions ? 'repeat' extends keyof Options ? Options['repeat'] : undefined : undefined;
+type SequenceReadKind<Pins, Repeat> = Pins extends readonly number[] ? 'collection' : Repeat extends undefined | 1 ? 'scalar' : number extends Repeat ? 'scalar' | 'collection' : 'collection';
+type SequenceWriteKind<Pins> = Pins extends readonly number[] ? number extends Pins['length'] ? 'scalar' | 'collection' : Pins['length'] extends 1 ? 'scalar' : 'collection' : 'scalar';
+type SequenceWithName<Names, Name extends string, Last> = string extends Name ? Names : Name extends string ? Names & { [Key in Name]: Last; } : never;
+type SequenceNode = {
+  readonly command: GpioSequenceCommand;
+  readonly name?: string;
+  readonly previous?: SequenceNode;
+  readonly length: number;
+};
+/** A digital level, or inclusive voltage bounds for an analog pin. */
+type GpioSequenceExpectation = v.InferOutput<typeof sequenceExpect>;
+/** A digital level, or a voltage for an analog pin. */
+type GpioSequenceValue = v.InferOutput<typeof sequenceValue>;
+type GpioSequenceReadOptions = {
+  repeat?: number;
+  delay?: number;
+  expect?: GpioSequenceExpectation;
+};
+/** A digital level: the strings the wire uses, or a boolean (`true` is high). */
+type GpioSequenceLevel = 'low' | 'high' | boolean;
+type GpioSequenceWaitOptions = {
+  timeout?: number;
+  stable_for?: number;
+};
+/** At least one edge is required; both together are an inclusive band. */
+type GpioSequenceWaitVoltageOptions = ({
+  min: number;
+  max?: number;
+} | {
+  max: number;
+  min?: number;
+}) & GpioSequenceWaitOptions;
+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;
+  private count;
+  constructor(fetch: UpFetch, info: Information);
+  /**
+   * Resets all IO configurations to default.
+   */
+  reset(): Promise<void>;
+  /**
+   * Access a specific digital IO pin by id.
+   * @param io The IO pin id.
+   * @returns The digital IO instance.
+   */
+  digital(io: number): DigitalIO;
+  /**
+   * Access a specific analog IO pin by id.
+   * @param io The IO pin id.
+   * @returns The analog IO instance.
+   */
+  analog(io: number): AnalogIO;
+  /**
+   * Holds the current state of all GPIO pins.
+   * @returns The applied sync state.
+   */
+  hold(): Promise<SyncConfiguration>;
+  /**
+   * Releases control of the IO pins, allowing external control.
+   *
+   * This also sets the device as a slave.
+   *
+   * @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>;
+  /**
+   * Starts a command sequence.
+   *
+   * The device runs every appended command back to back, holding the IO subsystem for
+   * the whole run, so no other IO request interleaves. Every pin used must be
+   * configured before `run()`.
+   *
+   * @returns An empty sequence builder.
+   */
+  sequence(): GpioSequence;
+}
+/** @hideconstructor */
+declare class DigitalIO {
+  private readonly fetch;
+  readonly id: number;
+  constructor(fetch: UpFetch, id: number);
+  /**
+   * Configure the pin as a digital input.
+   * @param config The digital input configuration.
+   * @returns The applied configuration.
+   */
+  configure_input(config: PartialDigitalInputConfiguration): Promise<DigitalInputConfiguration>;
+  /**
+   * Configures the pin as a digital output.
+   * @param config The digital output configuration.
+   * @returns The applied configuration.
+   */
+  configure_output(config: PartialDigitalOutputConfiguration): Promise<DigitalOutputConfiguration>;
+  /**
+   * Reads the current state of the pin.
+   * @returns The current state of the pin.
+   */
+  read(): Promise<boolean>;
+  /**
+   * Writes a value to the pin.
+   * @param value The value to write.
+   * @returns The written value.
+   */
+  write(value: boolean | number): Promise<boolean>;
+  /**
+   * Configure the pin as an open drain output.
+   * @param config The open drain configuration.
+   * @returns The applied configuration.
+   */
+  configure_open_drain(config: PartialOpenDrainConfiguration): Promise<OpenDrainConfiguration>;
+}
+/** @hideconstructor */
+declare class AnalogIO {
+  private readonly fetch;
+  readonly id: number;
+  constructor(fetch: UpFetch, id: number);
+  /**
+   * Configures the pin as an analog input.
+   * @returns The applied configuration.
+   * @returns The applied configuration.
+   */
+  configure_input(): Promise<AnalogInputConfiguration>;
+  /**
+   * Configures the pin as an analog output.
+   * @param config The analog output configuration.
+   * @returns The applied configuration.
+   */
+  configure_output(value: AnalogOutputLevel): Promise<AnalogOutputConfiguration>;
+  /**
+   * Reads the current state of the pin.
+   * @returns The current state of the pin.
+   */
+  read(): Promise<number>;
+  /**
+   * Writes a value to the pin.
+   * @param value The value to write.
+   * @returns The written value.
+   */
+  write(value: number): Promise<number>;
+}
+/**
+ * A list of IO commands the device runs back to back.
+ *
+ * Nothing is sent until `run()`. `repeat`, `delay`, `expect` and `stable_for` are
+ * device-side parameters: the builder never expands one appended command into several,
+ * and never loops client-side. A builder is reusable — `run()` keeps the commands, so
+ * the same sequence can be run again.
+ *
+ * @hideconstructor
+ */
+declare class GpioSequence<Names = {}, Last = never> {
+  private readonly fetch;
+  private readonly count;
+  private readonly tail?;
+  constructor(fetch: UpFetch, count: number, tail?: SequenceNode | undefined);
+  /**
+   * Reads one pin, or several pins in the order given.
+   *
+   * `repeat` is the total number of readings of the whole pin list (1 when omitted) and
+   * `delay` is the gap in seconds between passes: the first pass runs immediately, every
+   * later pass waits `delay`, nothing waits after the last one, and nothing waits
+   * between the pins of one pass. It is an end-to-start gap, not a sampling interval,
+   * so the effective period is `delay` plus however long a pass takes. `expect` is
+   * asserted on every reading: a boolean needs digital pins, inclusive `{ min, max }`
+   * volts needs analog pins. A failed assertion fails the whole run with
+   * `SEQUENCE_ASSERTION_FAILED`.
+   *
+   * @param io The pin, or the distinct pins to read in order.
+   * @param options Repetition, inter-pass gap and assertion.
+   * @returns An independent builder with this command appended.
+   */
+  read<const Pins extends number | readonly number[], const Options extends GpioSequenceReadOptions | undefined = undefined>(io: Pins, options?: Options): GpioSequence<Names, SequenceDescriptor<'read', SequenceReadKind<Pins, SequenceReadRepeat<Options>>>>;
+  /**
+   * Writes one pin, or several pins in the order given.
+   *
+   * A single `value` is applied to every listed pin; an array pairs one value per pin,
+   * in the order of `io`, and must be exactly as long as the pin list. Each pin's
+   * configured mode decides what its value means, exactly like the per-pin API: on a
+   * digital pin a number is a level (`0` low, anything else high), on an analog pin a
+   * number is volts, and a boolean written to an analog pin is rejected by the device.
+   * The pins are independent, so one command may mix a digital level and an analog
+   * voltage. Closed-loop output correction still runs per pin, so a multi-pin analog
+   * write costs one correction per pin. Writing a pin several times, or spacing writes
+   * out, means appending more `write` commands with `delay()` between them.
+   *
+   * A write of one pin reports the applied `value`; a write of several reports
+   * `samples`, one entry per pin in the order they were driven.
+   *
+   * @param io The pin, or the distinct pins to write in order.
+   * @param value The value applied to every pin, or one value per pin.
+   * @returns An independent builder with this command appended.
+   */
+  write<const Pins extends number | readonly number[]>(io: Pins, value: GpioSequenceValue | readonly GpioSequenceValue[]): GpioSequence<Names, SequenceDescriptor<'write', SequenceWriteKind<Pins>>>;
+  /**
+   * Waits for an analog pin to read inside a voltage bound.
+   *
+   * The pin must be in `analog` mode; the device rejects a digital one, which
+   * {@link GpioSequence.wait_level} handles instead. `min` alone waits for the pin to
+   * read at or above it, `max` alone for at or below it, and the two together for the
+   * inclusive band they describe; at least one is required and `min` must not be above
+   * `max`. The semantics are on the sample, not the edge, so a pin already inside the
+   * bound completes immediately. `stable_for` (seconds) requires the bound to hold
+   * across samples spanning that long; any sample outside it restarts the window.
+   * Voltages come from polled ADC samples, so an excursion shorter than the interval
+   * between two samples is invisible. A wait that exceeds its `timeout` fails the whole
+   * run with `SEQUENCE_TIMED_OUT`.
+   *
+   * @param io The pin to watch.
+   * @param options The bound edges in volts, time budget and stability window.
+   * @returns An independent builder with this command appended.
+   */
+  wait_voltage(io: number, options: GpioSequenceWaitVoltageOptions): GpioSequence<Names, SequenceDescriptor<'wait_voltage', 'scalar'>>;
+  /**
+   * Waits for a digital pin to read a level.
+   *
+   * The pin must be in `digital` mode; the device rejects an analog one, which
+   * {@link GpioSequence.wait_voltage} handles instead. The level is resolved from the
+   * pin's configured `vil`/`vih`. The semantics are on the level, not the edge, so a pin
+   * that already reads the level completes immediately. `stable_for` (seconds) requires
+   * the level to hold across samples spanning that long; any sample that fails the
+   * condition restarts the window. Levels come from polled ADC samples, so a transition
+   * shorter than the interval between two samples is invisible. A wait that exceeds its
+   * `timeout` fails the whole run with `SEQUENCE_TIMED_OUT`.
+   *
+   * @param io The pin to watch.
+   * @param level The level to wait for, as `'low'`/`'high'` or a boolean.
+   * @param options Time budget and stability window.
+   * @returns An independent builder with this command appended.
+   */
+  wait_level(io: number, level: GpioSequenceLevel, options?: GpioSequenceWaitOptions): GpioSequence<Names, SequenceDescriptor<'wait_level', 'scalar'>>;
+  /**
+   * Sleeps, holding the IO subsystem.
+   * @param duration Seconds to sleep.
+   * @returns An independent builder with this command appended.
+   */
+  delay(duration: number): GpioSequence<Names, SequenceDescriptor<'delay', 'control'>>;
+  /**
+   * Holds synchronization, freezing the analog outputs for the rest of the sequence.
+   * @returns An independent builder with this command appended.
+   */
+  hold(): GpioSequence<Names, SequenceDescriptor<'hold', 'control'>>;
+  /**
+   * Releases synchronization, applying every output staged while it was held.
+   * @returns An independent builder with this command appended.
+   */
+  release(): GpioSequence<Names, SequenceDescriptor<'release', 'control'>>;
+  /** Names the preceding command without changing this builder or the wire request. */
+  as<const Name extends string>(name: Name & ([Last] extends [never] ? never : Name extends keyof Names ? never : unknown)): GpioSequence<SequenceWithName<Names, Name, Last>, never>;
+  /**
+   * Runs the sequence on the device.
+   *
+   * A wait that times out, a sequence that exceeds its budget and a failed read
+   * assertion reject with an `ApiError` whose `code` is `SEQUENCE_TIMED_OUT` or
+   * `SEQUENCE_ASSERTION_FAILED`; nothing after the stopping command runs, and no
+   * partial report is produced.
+   *
+   * @param options Total time budget in seconds, 30 when omitted.
+   * @returns One result per appended command.
+   */
+  run(options?: {
+    timeout?: number;
+  }): Promise<GpioSequenceReport<Names>>;
+  private pinList;
+  private check;
+  private append;
+}
+//#endregion
+export { analogState as A, PartialDigitalInputConfiguration as C, SyncState as D, SyncConfiguration as E, openDrainConfiguration as F, syncState as I, digitalOutputConfiguration as M, digitalState as N, analogInputConfiguration as O, gpioConfiguration as P, PartialAnalogOutputConfiguration as S, PartialOpenDrainConfiguration as T, GpioSequenceStep as _, DigitalInputConfiguration as a, GpioSequenceWaitVoltageOptions as b, GpioConfiguration as c, GpioSequenceExpectation as d, GpioSequenceLevel as f, GpioSequenceSample as g, GpioSequenceReport as h, DigitalIO as i, digitalInputConfiguration as j, analogOutputConfiguration as k, GpioSequence as l, GpioSequenceReadOptions as m, AnalogInputConfiguration as n, DigitalOutputConfiguration as o, GpioSequenceNamedResult as p, AnalogOutputConfiguration as r, GpioApi as s, AnalogIO as t, GpioSequenceCommand as u, GpioSequenceValue as v, PartialDigitalOutputConfiguration as w, OpenDrainConfiguration as x, GpioSequenceWaitOptions as y };
+//# sourceMappingURL=gpio-5-tRkdTW.d.mts.map