@synnaxlabs/client 0.56.2 → 0.57.1

package/src/ni/types.gen.ts

@@ -0,0 +1,1632 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { id } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { channel } from "@/channel";
+import { device } from "@/device";
+import { task } from "@/task";
+
+export const TERMINAL_CONFIGS = [
+  "Cfg_Default",
+  "RSE",
+  "NRSE",
+  "Diff",
+  "PseudoDiff",
+] as const;
+export const terminalConfigZ = z.enum(TERMINAL_CONFIGS);
+export type TerminalConfig = z.infer<typeof terminalConfigZ>;
+
+export const EXCITATION_SOURCES = ["Internal", "External", "None"] as const;
+export const excitationSourceZ = z.enum(EXCITATION_SOURCES);
+export type ExcitationSource = z.infer<typeof excitationSourceZ>;
+
+export const BRIDGE_CONFIGS = ["FullBridge", "HalfBridge", "QuarterBridge"] as const;
+export const bridgeConfigZ = z.enum(BRIDGE_CONFIGS);
+export type BridgeConfig = z.infer<typeof bridgeConfigZ>;
+
+export const ELECTRICAL_UNITS = ["mVoltsPerVolt", "VoltsPerVolt"] as const;
+export const electricalUnitsZ = z.enum(ELECTRICAL_UNITS);
+export type ElectricalUnits = z.infer<typeof electricalUnitsZ>;
+
+export const RESISTANCE_CONFIGS = ["2Wire", "3Wire", "4Wire"] as const;
+export const resistanceConfigZ = z.enum(RESISTANCE_CONFIGS);
+export type ResistanceConfig = z.infer<typeof resistanceConfigZ>;
+
+export const Z_INDEX_PHASES = [
+  "AHighBHigh",
+  "AHighBLow",
+  "ALowBHigh",
+  "ALowBLow",
+] as const;
+export const zIndexPhaseZ = z.enum(Z_INDEX_PHASES);
+export type ZIndexPhase = z.infer<typeof zIndexPhaseZ>;
+
+export const UNITS = [
+  "Volts",
+  "Amps",
+  "DegF",
+  "DegC",
+  "DegR",
+  "Kelvins",
+  "Strain",
+  "Ohms",
+  "Hz",
+  "Seconds",
+  "Meters",
+  "Inches",
+  "Degrees",
+  "Radians",
+  "g",
+  "MetersPerSecondSquared",
+  "Newtons",
+  "Pounds",
+  "KilogramForce",
+  "PoundsPerSquareInch",
+  "Bar",
+  "Pascals",
+  "VoltsPerVolt",
+  "mVoltsPerVolt",
+  "NewtonMeters",
+  "InchPounds",
+  "InchOunces",
+  "FootPounds",
+] as const;
+export const unitsZ = z.enum(UNITS);
+export type Units = z.infer<typeof unitsZ>;
+
+export const ACCEL_SENSITIVITY_UNITS = ["mVoltsPerG", "VoltsPerG"] as const;
+export const accelSensitivityUnitsZ = z.enum(ACCEL_SENSITIVITY_UNITS);
+export type AccelSensitivityUnits = z.infer<typeof accelSensitivityUnitsZ>;
+
+export const ACCEL_UNITS = [
+  "g",
+  "MetersPerSecondSquared",
+  "InchesPerSecondSquared",
+] as const;
+export const accelUnitsZ = z.enum(ACCEL_UNITS);
+export type AccelUnits = z.infer<typeof accelUnitsZ>;
+
+export const FORCE_UNITS = ["Newtons", "Pounds", "KilogramForce"] as const;
+export const forceUnitsZ = z.enum(FORCE_UNITS);
+export type ForceUnits = z.infer<typeof forceUnitsZ>;
+
+export const SHUNT_RESISTOR_LOCATIONS = ["Default", "Internal", "External"] as const;
+export const shuntResistorLocationZ = z.enum(SHUNT_RESISTOR_LOCATIONS);
+export type ShuntResistorLocation = z.infer<typeof shuntResistorLocationZ>;
+
+export const FORCE_SENSITIVITY_UNITS = ["mVoltsPerNewton", "mVoltsPerPound"] as const;
+export const forceSensitivityUnitsZ = z.enum(FORCE_SENSITIVITY_UNITS);
+export type ForceSensitivityUnits = z.infer<typeof forceSensitivityUnitsZ>;
+
+export const PRESSURE_UNITS = ["PoundsPerSquareInch", "Pascals", "Bar"] as const;
+export const pressureUnitsZ = z.enum(PRESSURE_UNITS);
+export type PressureUnits = z.infer<typeof pressureUnitsZ>;
+
+export const TORQUE_UNITS = [
+  "NewtonMeters",
+  "InchOunces",
+  "InchPounds",
+  "FootPounds",
+] as const;
+export const torqueUnitsZ = z.enum(TORQUE_UNITS);
+export type TorqueUnits = z.infer<typeof torqueUnitsZ>;
+
+export const TEMPERATURE_UNITS = ["DegC", "DegF", "Kelvins", "DegR"] as const;
+export const temperatureUnitsZ = z.enum(TEMPERATURE_UNITS);
+export type TemperatureUnits = z.infer<typeof temperatureUnitsZ>;
+
+export const RTD_TYPES = [
+  "Pt3750",
+  "Pt3851",
+  "Pt3911",
+  "Pt3916",
+  "Pt3920",
+  "Pt3928",
+] as const;
+export const rtdTypeZ = z.enum(RTD_TYPES);
+export type RTDType = z.infer<typeof rtdTypeZ>;
+
+export const STRAIN_CONFIGS = [
+  "FullBridgeI",
+  "FullBridgeII",
+  "FullBridgeIII",
+  "HalfBridgeI",
+  "HalfBridgeII",
+  "QuarterBridgeI",
+  "QuarterBridgeII",
+] as const;
+export const strainConfigZ = z.enum(STRAIN_CONFIGS);
+export type StrainConfig = z.infer<typeof strainConfigZ>;
+
+export const THERMOCOUPLE_TYPES = ["J", "K", "N", "R", "S", "T", "B", "E"] as const;
+export const thermocoupleTypeZ = z.enum(THERMOCOUPLE_TYPES);
+export type ThermocoupleType = z.infer<typeof thermocoupleTypeZ>;
+
+export const VELOCITY_UNITS = ["MetersPerSecond", "InchesPerSecond"] as const;
+export const velocityUnitsZ = z.enum(VELOCITY_UNITS);
+export type VelocityUnits = z.infer<typeof velocityUnitsZ>;
+
+export const VELOCITY_SENSITIVITY_UNITS = [
+  "MillivoltsPerMillimeterPerSecond",
+  "MilliVoltsPerInchPerSecond",
+] as const;
+export const velocitySensitivityUnitsZ = z.enum(VELOCITY_SENSITIVITY_UNITS);
+export type VelocitySensitivityUnits = z.infer<typeof velocitySensitivityUnitsZ>;
+
+export const CHARGE_UNITS = ["Coulombs", "PicoCoulombs"] as const;
+export const chargeUnitsZ = z.enum(CHARGE_UNITS);
+export type ChargeUnits = z.infer<typeof chargeUnitsZ>;
+
+export const CI_EDGES = ["Rising", "Falling"] as const;
+export const ciEdgeZ = z.enum(CI_EDGES);
+export type CIEdge = z.infer<typeof ciEdgeZ>;
+
+export const CI_MEAS_METHODS = [
+  "LowFreq1Ctr",
+  "HighFreq2Ctr",
+  "LargeRng2Ctr",
+  "DynamicAvg",
+] as const;
+export const ciMeasMethodZ = z.enum(CI_MEAS_METHODS);
+export type CIMeasMethod = z.infer<typeof ciMeasMethodZ>;
+
+export const CI_FREQ_UNITS = ["Hz", "Ticks"] as const;
+export const ciFreqUnitsZ = z.enum(CI_FREQ_UNITS);
+export type CIFreqUnits = z.infer<typeof ciFreqUnitsZ>;
+
+export const CI_TIME_UNITS = ["Seconds", "Ticks"] as const;
+export const ciTimeUnitsZ = z.enum(CI_TIME_UNITS);
+export type CITimeUnits = z.infer<typeof ciTimeUnitsZ>;
+
+export const CI_COUNT_DIRECTIONS = [
+  "CountUp",
+  "CountDown",
+  "ExternallyControlled",
+] as const;
+export const ciCountDirectionZ = z.enum(CI_COUNT_DIRECTIONS);
+export type CICountDirection = z.infer<typeof ciCountDirectionZ>;
+
+export const CI_DECODING_TYPES = ["X1", "X2", "X4", "TwoPulse"] as const;
+export const ciDecodingTypeZ = z.enum(CI_DECODING_TYPES);
+export type CIDecodingType = z.infer<typeof ciDecodingTypeZ>;
+
+export const CI_LINEAR_VELOCITY_UNITS = ["m/s", "in/s"] as const;
+export const ciLinearVelocityUnitsZ = z.enum(CI_LINEAR_VELOCITY_UNITS);
+export type CILinearVelocityUnits = z.infer<typeof ciLinearVelocityUnitsZ>;
+
+export const CI_ANGULAR_VELOCITY_UNITS = ["RPM", "Radians/s", "Degrees/s"] as const;
+export const ciAngularVelocityUnitsZ = z.enum(CI_ANGULAR_VELOCITY_UNITS);
+export type CIAngularVelocityUnits = z.infer<typeof ciAngularVelocityUnitsZ>;
+
+export const CI_LINEAR_POSITION_UNITS = ["Meters", "Inches", "Ticks"] as const;
+export const ciLinearPositionUnitsZ = z.enum(CI_LINEAR_POSITION_UNITS);
+export type CILinearPositionUnits = z.infer<typeof ciLinearPositionUnitsZ>;
+
+export const CI_ANGULAR_POSITION_UNITS = ["Degrees", "Radians", "Ticks"] as const;
+export const ciAngularPositionUnitsZ = z.enum(CI_ANGULAR_POSITION_UNITS);
+export type CIAngularPositionUnits = z.infer<typeof ciAngularPositionUnitsZ>;
+
+export const WAVE_TYPES = ["Sine", "Triangle", "Square", "Sawtooth"] as const;
+export const waveTypeZ = z.enum(WAVE_TYPES);
+export type WaveType = z.infer<typeof waveTypeZ>;
+
+export const ACCEL_CHARGE_SENSITIVITY_UNITS = [
+  "PicoCoulombsPerG",
+  "PicoCoulombsPerMetersPerSecondSquared",
+  "PicoCoulombsPerInchesPerSecondSquared",
+] as const;
+export const accelChargeSensitivityUnitsZ = z.enum(ACCEL_CHARGE_SENSITIVITY_UNITS);
+export type AccelChargeSensitivityUnits = z.infer<typeof accelChargeSensitivityUnitsZ>;
+
+/** MinMaxVal bounds the expected signal range in scaled units. */
+export const minMaxValZ = z.object({
+  /** minVal is the minimum expected value, in scaled units. */
+  minVal: z.number().default(0),
+  /** maxVal is the maximum expected value, in scaled units. */
+  maxVal: z.number().default(1),
+});
+export interface MinMaxVal extends z.infer<typeof minMaxValZ> {}
+
+/** Terminal configures the terminal wiring of an analog input channel. */
+export const terminalZ = z.object({
+  /** terminalConfig selects the terminal configuration (RSE, NRSE, Diff, ...). */
+  terminalConfig: terminalConfigZ.default("Cfg_Default"),
+});
+export interface Terminal extends z.infer<typeof terminalZ> {}
+
+/** Sensitivity specifies a sensor's sensitivity rating. */
+export const sensitivityZ = z.object({
+  /** sensitivity is the sensor's sensitivity rating. */
+  sensitivity: z.number().default(0),
+});
+export interface Sensitivity extends z.infer<typeof sensitivityZ> {}
+
+/** CurrentExcitation configures the current excitation supplied to a sensor. */
+export const currentExcitationZ = z.object({
+  /** currentExcitSource selects the source of the current excitation signal. */
+  currentExcitSource: excitationSourceZ.default("Internal"),
+  /** currentExcitVal is the current excitation level, in Amps. */
+  currentExcitVal: z.number().default(0),
+});
+export interface CurrentExcitation extends z.infer<typeof currentExcitationZ> {}
+
+/** VoltageExcitation configures the voltage excitation supplied to a sensor. */
+export const voltageExcitationZ = z.object({
+  /** voltageExcitSource selects the source of the voltage excitation signal. */
+  voltageExcitSource: excitationSourceZ.default("Internal"),
+  /** voltageExcitVal is the voltage excitation level, in Volts. */
+  voltageExcitVal: z.number().default(0),
+});
+export interface VoltageExcitation extends z.infer<typeof voltageExcitationZ> {}
+
+/** Bridge configures the wiring and nominal resistance of a bridge-based sensor. */
+export const bridgeZ = z.object({
+  /** bridgeConfig selects the physical bridge wiring. */
+  bridgeConfig: bridgeConfigZ.default("FullBridge"),
+  /** nominalBridgeResistance is the nominal resistance of the bridge, in Ohms. */
+  nominalBridgeResistance: z.number().default(1),
+});
+export interface Bridge extends z.infer<typeof bridgeZ> {}
+
+/**
+ * BridgePolynomial scales bridge electrical output to physical units with a polynomial.
+ */
+export const bridgePolynomialZ = z.object({
+  /** forwardCoeffs are the coefficients mapping electrical to physical values. */
+  forwardCoeffs: z
+    .number()
+    .array()
+    .default(() => []),
+  /** reverseCoeffs are the coefficients mapping physical to electrical values. */
+  reverseCoeffs: z
+    .number()
+    .array()
+    .default(() => []),
+  /** electricalUnits are the electrical output units of the bridge. */
+  electricalUnits: electricalUnitsZ.default("mVoltsPerVolt"),
+});
+export interface BridgePolynomial extends z.infer<typeof bridgePolynomialZ> {}
+
+/** Resistance configures the wiring of a resistance measurement. */
+export const resistanceZ = z.object({
+  /**
+   * resistanceConfig selects the number of wires used for the resistance measurement.
+   */
+  resistanceConfig: resistanceConfigZ.default("2Wire"),
+});
+export interface Resistance extends z.infer<typeof resistanceZ> {}
+
+/** Table scales bridge electrical output to physical units with a lookup table. */
+export const tableZ = z.object({
+  /** electricalVals are the electrical breakpoints of the calibration table. */
+  electricalVals: z
+    .number()
+    .array()
+    .default(() => []),
+  /** electricalUnits are the units of the electrical breakpoints. */
+  electricalUnits: electricalUnitsZ.default("mVoltsPerVolt"),
+  /**
+   * physicalVals are the physical values corresponding to each electrical breakpoint.
+   */
+  physicalVals: z
+    .number()
+    .array()
+    .default(() => []),
+});
+export interface Table extends z.infer<typeof tableZ> {}
+
+/**
+ * TwoPointLin scales bridge electrical output to physical units between two calibration
+ * points.
+ */
+export const twoPointLinZ = z.object({
+  /** firstElectricalVal is the first electrical calibration point. */
+  firstElectricalVal: z.number().default(0),
+  /** secondElectricalVal is the second electrical calibration point. */
+  secondElectricalVal: z.number().default(1),
+  /** electricalUnits are the units of the electrical calibration points. */
+  electricalUnits: electricalUnitsZ.default("mVoltsPerVolt"),
+  /** firstPhysicalVal is the physical value at the first electrical point. */
+  firstPhysicalVal: z.number().default(0),
+  /** secondPhysicalVal is the physical value at the second electrical point. */
+  secondPhysicalVal: z.number().default(1),
+});
+export interface TwoPointLin extends z.infer<typeof twoPointLinZ> {}
+
+/** BaseAIChannel carries the fields every NI analog input channel shares. */
+export const baseAIChannelZ = z.object({
+  /** key uniquely identifies the channel within the task. */
+  key: z.string().default(id.create),
+  /** name is the human-readable channel name. */
+  name: z.string().default(""),
+  /** disabled is true when the channel is excluded from acquisition. */
+  disabled: z.boolean().default(false),
+  /** channel is the Synnax channel that raw samples are written to. */
+  channel: channel.keyZ.default(0),
+  /** port is the physical port the channel reads from. */
+  port: z.int32().default(0),
+  /** device is the key of the device the channel belongs to. */
+  device: device.keyZ.default(""),
+});
+export interface BaseAIChannel extends z.infer<typeof baseAIChannelZ> {}
+
+/** ZIndex configures the Z-index reset behavior of an encoder. */
+export const zIndexZ = z.object({
+  /** zIndexEnabled is true when the encoder's Z index resets the count. */
+  zIndexEnabled: z.boolean().default(false),
+  /** zIndexVal is the value the measurement resets to when the Z index is active. */
+  zIndexVal: z.number().default(0),
+  /** zIndexPhase selects the A/B states at which the Z index is active. */
+  zIndexPhase: zIndexPhaseZ.default("AHighBHigh"),
+  /** terminalZ is the terminal the Z index signal is wired to. */
+  terminalZ: z.string().default(""),
+});
+export interface ZIndex extends z.infer<typeof zIndexZ> {}
+
+/** BaseCIChannel carries the fields every NI counter input channel shares. */
+export const baseCIChannelZ = z.object({
+  /** key uniquely identifies the channel within the task. */
+  key: z.string().default(id.create),
+  /** name is the human-readable channel name. */
+  name: z.string().default(""),
+  /** disabled is true when the channel is excluded from acquisition. */
+  disabled: z.boolean().default(false),
+  /** channel is the Synnax channel that raw samples are written to. */
+  channel: channel.keyZ.default(0),
+  /** port is the physical counter the channel uses. */
+  port: z.int32().default(0),
+  /** device is the key of the device the counter belongs to. */
+  device: device.keyZ.default(""),
+});
+export interface BaseCIChannel extends z.infer<typeof baseCIChannelZ> {}
+
+/** BaseAOChannel carries the fields every NI analog output channel shares. */
+export const baseAOChannelZ = z.object({
+  /** key uniquely identifies the channel within the task. */
+  key: z.string().default(id.create),
+  /** disabled is true when the channel is excluded from the task. */
+  disabled: z.boolean().default(false),
+  /** cmdChannel is the Synnax channel commands are read from. */
+  cmdChannel: channel.keyZ.default(0),
+  /** stateChannel is the Synnax channel the output state is written to. */
+  stateChannel: channel.keyZ.default(0),
+  /** cmdChannelName is the human-readable name of the command channel. */
+  cmdChannelName: z.string().default(""),
+  /** stateChannelName is the human-readable name of the state channel. */
+  stateChannelName: z.string().default(""),
+  /** port is the physical port the channel writes to. */
+  port: z.int32().default(0),
+});
+export interface BaseAOChannel extends z.infer<typeof baseAOChannelZ> {}
+
+/** DIChannel is a digital input channel the task acquires from. */
+export const diChannelZ = z.object({
+  /** key uniquely identifies the channel within the task. */
+  key: z.string().default(id.create),
+  /** name is the human-readable channel name. */
+  name: z.string().default(""),
+  /** disabled is true when the channel is excluded from acquisition. */
+  disabled: z.boolean().default(false),
+  /** channel is the Synnax channel that raw samples are written to. */
+  channel: channel.keyZ.default(0),
+  /** port is the physical port the channel reads from. */
+  port: z.int32().default(0),
+  /** line is the digital line within the port the channel reads from. */
+  line: z.int32().default(0),
+});
+export interface DIChannel extends z.infer<typeof diChannelZ> {}
+
+/** DOChannel is a digital output channel the task drives. */
+export const doChannelZ = z.object({
+  /** key uniquely identifies the channel within the task. */
+  key: z.string().default(id.create),
+  /** disabled is true when the channel is excluded from the task. */
+  disabled: z.boolean().default(false),
+  /** cmdChannel is the Synnax channel commands are read from. */
+  cmdChannel: channel.keyZ.default(0),
+  /** stateChannel is the Synnax channel the output state is written to. */
+  stateChannel: channel.keyZ.default(0),
+  /** cmdChannelName is the human-readable name of the command channel. */
+  cmdChannelName: z.string().default(""),
+  /** stateChannelName is the human-readable name of the state channel. */
+  stateChannelName: z.string().default(""),
+  /** port is the physical port the channel writes to. */
+  port: z.int32().default(0),
+  /** line is the digital line within the port the channel writes to. */
+  line: z.int32().default(0),
+});
+export interface DOChannel extends z.infer<typeof doChannelZ> {}
+
+export const writeConfigZ = task.writeConfigZ.extend({
+  stateRate: z.number().default(10),
+});
+export interface WriteConfig extends z.infer<typeof writeConfigZ> {}
+
+export const scanConfigZ = task.scanConfigZ.extend({
+  ignoredModels: z.string().array().default(["^cRIO.*", "^nown.*"]),
+});
+export interface ScanConfig extends z.infer<typeof scanConfigZ> {}
+
+/** BuiltInCJC reads the reference temperature from the device's own sensor. */
+export const builtInCJCZ = z.object({
+  source: z.literal("built_in"),
+});
+export interface BuiltInCJC extends z.infer<typeof builtInCJCZ> {}
+
+/** ConstValCJC uses a fixed reference temperature. */
+export const constValCJCZ = z.object({
+  source: z.literal("const_val"),
+  /** val is the reference temperature, in the channel's units. */
+  val: z.number().default(0),
+});
+export interface ConstValCJC extends z.infer<typeof constValCJCZ> {}
+
+/** ChanCJC reads the reference temperature from another channel. */
+export const chanCJCZ = z.object({
+  source: z.literal("chan"),
+  /** port is the port of the channel that measures the reference. */
+  port: z.int32().default(0),
+});
+export interface ChanCJC extends z.infer<typeof chanCJCZ> {}
+
+export const CJC_TYPES = ["built_in", "const_val", "chan"] as const;
+export const cjcTypeZ = z.enum(CJC_TYPES);
+export type CJCType = z.infer<typeof cjcTypeZ>;
+
+/**
+ * CJC is the cold-junction compensation for a thermocouple. The source selects where
+ * the reference temperature comes from.
+ */
+export const cjcZ = z.discriminatedUnion("source", [
+  builtInCJCZ,
+  constValCJCZ,
+  chanCJCZ,
+]);
+export type CJC = BuiltInCJC | ConstValCJC | ChanCJC;
+
+export const CJC_SCHEMAS: {
+  [K in CJCType]: z.ZodType<Extract<CJC, { source: K }>>;
+} = {
+  built_in: builtInCJCZ,
+  const_val: constValCJCZ,
+  chan: chanCJCZ,
+};
+
+/** LinearScale maps raw values to engineering units with a slope and intercept. */
+export const linearScaleZ = z.object({
+  type: z.literal("linear"),
+  /** slope is the multiplier applied to the raw value. */
+  slope: z.number().default(1),
+  /** yIntercept is the offset added after scaling. */
+  yIntercept: z.number().default(0),
+  /** preScaledUnits are the units of the raw value before scaling. */
+  preScaledUnits: unitsZ.default("Volts"),
+  /** scaledUnits are the units of the value after scaling. */
+  scaledUnits: z.string().default("Volts"),
+});
+export interface LinearScale extends z.infer<typeof linearScaleZ> {}
+
+/** MapScale maps a raw range linearly onto a scaled range. */
+export const mapScaleZ = z.object({
+  type: z.literal("map"),
+  /** preScaledMin is the lower bound of the raw input range. */
+  preScaledMin: z.number().default(0),
+  /** preScaledMax is the upper bound of the raw input range. */
+  preScaledMax: z.number().default(1),
+  /** scaledMin is the lower bound of the scaled output range. */
+  scaledMin: z.number().default(0),
+  /** scaledMax is the upper bound of the scaled output range. */
+  scaledMax: z.number().default(1),
+  /** preScaledUnits are the units of the raw value before scaling. */
+  preScaledUnits: unitsZ.default("Volts"),
+  /** scaledUnits are the units of the value after scaling. */
+  scaledUnits: z.string().default("Volts"),
+});
+export interface MapScale extends z.infer<typeof mapScaleZ> {}
+
+/** TableScale maps raw values to engineering units via a lookup table. */
+export const tableScaleZ = z.object({
+  type: z.literal("table"),
+  /** preScaledVals are the raw breakpoints, monotonically increasing. */
+  preScaledVals: z
+    .number()
+    .array()
+    .default(() => []),
+  /** scaledVals are the engineering-unit values at each breakpoint. */
+  scaledVals: z
+    .number()
+    .array()
+    .default(() => []),
+  /** preScaledUnits are the units of the raw values before scaling. */
+  preScaledUnits: unitsZ.default("Volts"),
+  /** scaledUnits are the units of the values after scaling. */
+  scaledUnits: z.string().default("Volts"),
+});
+export interface TableScale extends z.infer<typeof tableScaleZ> {}
+
+/** PolynomialScale maps raw values to engineering units with a polynomial. */
+export const polynomialScaleZ = z.object({
+  type: z.literal("polynomial"),
+  /** forwardCoeffs are the coefficients mapping pre-scaled to scaled values. */
+  forwardCoeffs: z
+    .number()
+    .array()
+    .default(() => []),
+  /** reverseCoeffs are the coefficients mapping scaled to pre-scaled values. */
+  reverseCoeffs: z
+    .number()
+    .array()
+    .default(() => []),
+  /** preScaledUnits are the units of the raw value before scaling. */
+  preScaledUnits: unitsZ.default("Volts"),
+  /** scaledUnits are the units of the value after scaling. */
+  scaledUnits: z.string().default("Volts"),
+});
+export interface PolynomialScale extends z.infer<typeof polynomialScaleZ> {}
+
+/** NoneScale applies no scaling; the raw value is used directly. */
+export const noneScaleZ = z.object({
+  type: z.literal("none"),
+});
+export interface NoneScale extends z.infer<typeof noneScaleZ> {}
+
+export const SCALE_TYPES = ["linear", "map", "table", "polynomial", "none"] as const;
+export const scaleTypeZ = z.enum(SCALE_TYPES);
+export type ScaleType = z.infer<typeof scaleTypeZ>;
+
+/** Scale determines how raw sensor values are transformed to engineering units. */
+export const scaleZ = z.discriminatedUnion("type", [
+  linearScaleZ,
+  mapScaleZ,
+  tableScaleZ,
+  polynomialScaleZ,
+  noneScaleZ,
+]);
+export type Scale = LinearScale | MapScale | TableScale | PolynomialScale | NoneScale;
+
+export const SCALE_SCHEMAS: {
+  [K in ScaleType]: z.ZodType<Extract<Scale, { type: K }>>;
+} = {
+  linear: linearScaleZ,
+  map: mapScaleZ,
+  table: tableScaleZ,
+  polynomial: polynomialScaleZ,
+  none: noneScaleZ,
+};
+
+export const digitalReadConfigZ = task.readConfigZ.extend({
+  device: device.keyZ.default(""),
+  channels: diChannelZ.array().default(() => []),
+});
+export interface DigitalReadConfig extends z.infer<typeof digitalReadConfigZ> {}
+
+export const digitalWriteConfigZ = writeConfigZ.extend({
+  channels: doChannelZ.array().default(() => []),
+});
+export interface DigitalWriteConfig extends z.infer<typeof digitalWriteConfigZ> {}
+
+/** CustomScale applies a user-defined scale to the raw measurement. */
+export const customScaleZ = z.object({
+  /** customScale is the scale applied to the raw measurement. */
+  customScale: scaleZ.prefault({ type: "none" }),
+});
+export interface CustomScale extends z.infer<typeof customScaleZ> {}
+
+/** AIVoltageChannel reads a voltage. */
+export const aiVoltageChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(terminalZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_voltage"),
+  });
+export interface AIVoltageChannel extends z.infer<typeof aiVoltageChannelZ> {}
+
+/** AIAccelChannel reads acceleration from an accelerometer. */
+export const aiAccelChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(terminalZ.shape)
+  .extend(sensitivityZ.shape)
+  .extend(currentExcitationZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_accel"),
+    /** units are the units of the acceleration measurement. */
+    units: accelUnitsZ.default("g"),
+    /** sensitivityUnits are the units of the accelerometer sensitivity. */
+    sensitivityUnits: accelSensitivityUnitsZ.default("mVoltsPerG"),
+  });
+export interface AIAccelChannel extends z.infer<typeof aiAccelChannelZ> {}
+
+/** AIBridgeChannel reads a generic bridge-based sensor. */
+export const aiBridgeChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(bridgeZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_bridge"),
+    /** units are the electrical output units of the bridge. */
+    units: electricalUnitsZ.default("mVoltsPerVolt"),
+  });
+export interface AIBridgeChannel extends z.infer<typeof aiBridgeChannelZ> {}
+
+/** AICurrentChannel reads a current. */
+export const aiCurrentChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(terminalZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_current"),
+    /** shuntResistorLoc selects where the shunt resistor is located. */
+    shuntResistorLoc: shuntResistorLocationZ.default("Default"),
+    /** extShuntResistorVal is the external shunt resistor value, in Ohms. */
+    extShuntResistorVal: z.number().default(1),
+  });
+export interface AICurrentChannel extends z.infer<typeof aiCurrentChannelZ> {}
+
+/** AIForceBridgeTableChannel reads force from a bridge with a calibration table. */
+export const aiForceBridgeTableChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(bridgeZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(tableZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_force_bridge_table"),
+    /** units are the units of the force measurement. */
+    units: forceUnitsZ.default("Newtons"),
+    /** physicalUnits are the physical units of the calibration table. */
+    physicalUnits: forceUnitsZ.default("Newtons"),
+  });
+export interface AIForceBridgeTableChannel extends z.infer<
+  typeof aiForceBridgeTableChannelZ
+> {}
+
+/**
+ * AIForceBridgeTwoPointLinChannel reads force from a bridge with two-point linear
+ * calibration.
+ */
+export const aiForceBridgeTwoPointLinChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(bridgeZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(twoPointLinZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_force_bridge_two_point_lin"),
+    /** units are the units of the force measurement. */
+    units: forceUnitsZ.default("Newtons"),
+    /** physicalUnits are the physical units of the two-point calibration. */
+    physicalUnits: forceUnitsZ.default("Newtons"),
+  });
+export interface AIForceBridgeTwoPointLinChannel extends z.infer<
+  typeof aiForceBridgeTwoPointLinChannelZ
+> {}
+
+/** AIForceIEPEChannel reads force from an IEPE sensor. */
+export const aiForceIEPEChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(terminalZ.shape)
+  .extend(sensitivityZ.shape)
+  .extend(currentExcitationZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_force_iepe"),
+    /** units are the units of the force measurement. */
+    units: forceUnitsZ.default("Newtons"),
+    /** sensitivityUnits are the units of the IEPE sensor sensitivity. */
+    sensitivityUnits: forceSensitivityUnitsZ.default("mVoltsPerNewton"),
+  });
+export interface AIForceIEPEChannel extends z.infer<typeof aiForceIEPEChannelZ> {}
+
+/** AIMicrophoneChannel reads sound pressure from a microphone. */
+export const aiMicrophoneChannelZ = baseAIChannelZ
+  .extend(terminalZ.shape)
+  .extend(currentExcitationZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_microphone"),
+    /** micSensitivity is the microphone sensitivity, in mV/Pa. */
+    micSensitivity: z.number().default(0),
+    /** maxSndPressLevel is the maximum expected sound pressure level, in dB. */
+    maxSndPressLevel: z.number().default(0),
+  });
+export interface AIMicrophoneChannel extends z.infer<typeof aiMicrophoneChannelZ> {}
+
+/**
+ * AIPressureBridgeTableChannel reads pressure from a bridge with a calibration table.
+ */
+export const aiPressureBridgeTableChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(bridgeZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(tableZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_pressure_bridge_table"),
+    /** units are the units of the pressure measurement. */
+    units: pressureUnitsZ.default("PoundsPerSquareInch"),
+    /** physicalUnits are the physical units of the calibration table. */
+    physicalUnits: pressureUnitsZ.default("PoundsPerSquareInch"),
+  });
+export interface AIPressureBridgeTableChannel extends z.infer<
+  typeof aiPressureBridgeTableChannelZ
+> {}
+
+/**
+ * AIPressureBridgeTwoPointLinChannel reads pressure from a bridge with two-point linear
+ * calibration.
+ */
+export const aiPressureBridgeTwoPointLinChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(bridgeZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(twoPointLinZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_pressure_bridge_two_point_lin"),
+    /** units are the units of the pressure measurement. */
+    units: pressureUnitsZ.default("PoundsPerSquareInch"),
+    /** physicalUnits are the physical units of the two-point calibration. */
+    physicalUnits: pressureUnitsZ.default("PoundsPerSquareInch"),
+  });
+export interface AIPressureBridgeTwoPointLinChannel extends z.infer<
+  typeof aiPressureBridgeTwoPointLinChannelZ
+> {}
+
+/** AIResistanceChannel reads a resistance. */
+export const aiResistanceChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(resistanceZ.shape)
+  .extend(currentExcitationZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_resistance"),
+  });
+export interface AIResistanceChannel extends z.infer<typeof aiResistanceChannelZ> {}
+
+/** AIRTDChannel reads temperature from an RTD. */
+export const aiRTDChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(resistanceZ.shape)
+  .extend(currentExcitationZ.shape)
+  .extend({
+    type: z.literal("ai_rtd"),
+    /** units are the units of the temperature measurement. */
+    units: temperatureUnitsZ.default("DegC"),
+    /** rtdType selects the RTD resistance-temperature curve. */
+    rtdType: rtdTypeZ.default("Pt3750"),
+    /** r0 is the sensor resistance at 0 degrees Celsius, in Ohms. */
+    r0: z.number().default(0),
+  });
+export interface AIRTDChannel extends z.infer<typeof aiRTDChannelZ> {}
+
+/** AIStrainGaugeChannel reads strain from a strain gauge. */
+export const aiStrainGaugeChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_strain_gauge"),
+    /** strainConfig selects the strain-gauge bridge configuration. */
+    strainConfig: strainConfigZ.default("FullBridgeI"),
+    /** gageFactor is the gauge factor of the strain gauge. */
+    gageFactor: z.number().default(0),
+    /** initialBridgeVoltage is the bridge output voltage in the unloaded state. */
+    initialBridgeVoltage: z.number().default(0),
+    /** nominalGageResistance is the nominal gauge resistance, in Ohms. */
+    nominalGageResistance: z.number().default(0),
+    /** poissonRatio is the Poisson ratio of the measured material. */
+    poissonRatio: z.number().default(0),
+    /** leadWireResistance is the resistance of the lead wires, in Ohms. */
+    leadWireResistance: z.number().default(0),
+  });
+export interface AIStrainGaugeChannel extends z.infer<typeof aiStrainGaugeChannelZ> {}
+
+/** AITempBuiltinChannel reads temperature from the device's built-in sensor. */
+export const aiTempBuiltinChannelZ = baseAIChannelZ.omit({ port: true }).extend({
+  type: z.literal("ai_temp_builtin"),
+  /** units are the units of the temperature measurement. */
+  units: temperatureUnitsZ.default("DegC"),
+});
+export interface AITempBuiltinChannel extends z.infer<typeof aiTempBuiltinChannelZ> {}
+
+/** AIThermocoupleChannel reads temperature from a thermocouple. */
+export const aiThermocoupleChannelZ = baseAIChannelZ.extend(minMaxValZ.shape).extend({
+  type: z.literal("ai_thermocouple"),
+  /** units are the units of the temperature measurement. */
+  units: temperatureUnitsZ.default("DegC"),
+  /** thermocoupleType selects the thermocouple alloy type. */
+  thermocoupleType: thermocoupleTypeZ.default("J"),
+  /** cjc is the cold-junction compensation applied to the reading. */
+  cjc: cjcZ.prefault({ source: "built_in" }),
+});
+export interface AIThermocoupleChannel extends z.infer<typeof aiThermocoupleChannelZ> {}
+
+/** AITorqueBridgeTableChannel reads torque from a bridge with a calibration table. */
+export const aiTorqueBridgeTableChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(bridgeZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(tableZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_torque_bridge_table"),
+    /** units are the units of the torque measurement. */
+    units: torqueUnitsZ.default("NewtonMeters"),
+    /** physicalUnits are the physical units of the calibration table. */
+    physicalUnits: torqueUnitsZ.default("NewtonMeters"),
+  });
+export interface AITorqueBridgeTableChannel extends z.infer<
+  typeof aiTorqueBridgeTableChannelZ
+> {}
+
+/**
+ * AITorqueBridgeTwoPointLinChannel reads torque from a bridge with two-point linear
+ * calibration.
+ */
+export const aiTorqueBridgeTwoPointLinChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(bridgeZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(twoPointLinZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_torque_bridge_two_point_lin"),
+    /** units are the units of the torque measurement. */
+    units: torqueUnitsZ.default("NewtonMeters"),
+    /** physicalUnits are the physical units of the two-point calibration. */
+    physicalUnits: torqueUnitsZ.default("NewtonMeters"),
+  });
+export interface AITorqueBridgeTwoPointLinChannel extends z.infer<
+  typeof aiTorqueBridgeTwoPointLinChannelZ
+> {}
+
+/** AIVelocityIEPEChannel reads velocity from an IEPE sensor. */
+export const aiVelocityIEPEChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(terminalZ.shape)
+  .extend(sensitivityZ.shape)
+  .extend(currentExcitationZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_velocity_iepe"),
+    /** units are the units of the velocity measurement. */
+    units: velocityUnitsZ.default("MetersPerSecond"),
+    /** sensitivityUnits are the units of the IEPE sensor sensitivity. */
+    sensitivityUnits: velocitySensitivityUnitsZ.default(
+      "MillivoltsPerMillimeterPerSecond",
+    ),
+  });
+export interface AIVelocityIEPEChannel extends z.infer<typeof aiVelocityIEPEChannelZ> {}
+
+/**
+ * AIAccel4WireDCVoltageChannel reads acceleration from a 4-wire DC-voltage
+ * accelerometer.
+ */
+export const aiAccel4WireDCVoltageChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(terminalZ.shape)
+  .extend(sensitivityZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_accel_4_wire_dc_voltage"),
+    /** units are the units of the acceleration measurement. */
+    units: accelUnitsZ.default("g"),
+    /** sensitivityUnits are the units of the accelerometer sensitivity. */
+    sensitivityUnits: accelSensitivityUnitsZ.default("mVoltsPerG"),
+    /**
+     * scaledByExcitation is true when the excitation voltage is used to scale the
+     * reading.
+     */
+    scaledByExcitation: z.boolean().default(false),
+  });
+export interface AIAccel4WireDCVoltageChannel extends z.infer<
+  typeof aiAccel4WireDCVoltageChannelZ
+> {}
+
+/** AIAccelChargeChannel reads acceleration from a charge-mode accelerometer. */
+export const aiAccelChargeChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(terminalZ.shape)
+  .extend(sensitivityZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_accel_charge"),
+    /** units are the units of the acceleration measurement. */
+    units: accelUnitsZ.default("g"),
+    /** sensitivityUnits are the units of the accelerometer sensitivity. */
+    sensitivityUnits: accelChargeSensitivityUnitsZ.default("PicoCoulombsPerG"),
+  });
+export interface AIAccelChargeChannel extends z.infer<typeof aiAccelChargeChannelZ> {}
+
+/** AIChargeChannel reads a raw charge. */
+export const aiChargeChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(terminalZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_charge"),
+    /** units are the units of the charge measurement. */
+    units: chargeUnitsZ.default("Coulombs"),
+  });
+export interface AIChargeChannel extends z.infer<typeof aiChargeChannelZ> {}
+
+/** AICurrentRMSChannel reads RMS current. */
+export const aiCurrentRMSChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(terminalZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_current_rms"),
+    /** shuntResistorLoc selects where the shunt resistor is located. */
+    shuntResistorLoc: shuntResistorLocationZ.default("Default"),
+    /** extShuntResistorVal is the external shunt resistor value, in Ohms. */
+    extShuntResistorVal: z.number().default(1),
+  });
+export interface AICurrentRMSChannel extends z.infer<typeof aiCurrentRMSChannelZ> {}
+
+/**
+ * AIForceBridgePolynomialChannel reads force from a bridge with polynomial calibration.
+ */
+export const aiForceBridgePolynomialChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(bridgeZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(bridgePolynomialZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_force_bridge_polynomial"),
+    /** units are the units of the force measurement. */
+    units: forceUnitsZ.default("Newtons"),
+    /** physicalUnits are the physical units of the polynomial calibration. */
+    physicalUnits: forceUnitsZ.default("Newtons"),
+  });
+export interface AIForceBridgePolynomialChannel extends z.infer<
+  typeof aiForceBridgePolynomialChannelZ
+> {}
+
+/** AIFreqVoltageChannel reads frequency from a voltage signal. */
+export const aiFreqVoltageChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_freq_voltage"),
+    /** thresholdLevel is the voltage level at which a cycle is counted. */
+    thresholdLevel: z.number().default(0),
+    /** hysteresis is the hysteresis applied around the threshold level. */
+    hysteresis: z.number().default(0),
+  });
+export interface AIFreqVoltageChannel extends z.infer<typeof aiFreqVoltageChannelZ> {}
+
+/**
+ * AIPressureBridgePolynomialChannel reads pressure from a bridge with polynomial
+ * calibration.
+ */
+export const aiPressureBridgePolynomialChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(bridgeZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(bridgePolynomialZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_pressure_bridge_polynomial"),
+    /** units are the units of the pressure measurement. */
+    units: pressureUnitsZ.default("PoundsPerSquareInch"),
+    /** physicalUnits are the physical units of the polynomial calibration. */
+    physicalUnits: pressureUnitsZ.default("PoundsPerSquareInch"),
+  });
+export interface AIPressureBridgePolynomialChannel extends z.infer<
+  typeof aiPressureBridgePolynomialChannelZ
+> {}
+
+/** AIThermistorIexChannel reads temperature from a current-excited thermistor. */
+export const aiThermistorIexChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(resistanceZ.shape)
+  .extend(currentExcitationZ.shape)
+  .extend({
+    type: z.literal("ai_thermistor_iex"),
+    /** units are the units of the temperature measurement. */
+    units: temperatureUnitsZ.default("DegC"),
+    /** a is the first Steinhart-Hart coefficient. */
+    a: z.number().default(0),
+    /** b is the second Steinhart-Hart coefficient. */
+    b: z.number().default(0),
+    /** c is the third Steinhart-Hart coefficient. */
+    c: z.number().default(0),
+  });
+export interface AIThermistorIexChannel extends z.infer<
+  typeof aiThermistorIexChannelZ
+> {}
+
+/** AIThermistorVexChannel reads temperature from a voltage-excited thermistor. */
+export const aiThermistorVexChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(resistanceZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend({
+    type: z.literal("ai_thermistor_vex"),
+    /** units are the units of the temperature measurement. */
+    units: temperatureUnitsZ.default("DegC"),
+    /** a is the first Steinhart-Hart coefficient. */
+    a: z.number().default(0),
+    /** b is the second Steinhart-Hart coefficient. */
+    b: z.number().default(0),
+    /** c is the third Steinhart-Hart coefficient. */
+    c: z.number().default(0),
+    /** r1 is the reference resistor value, in Ohms. */
+    r1: z.number().default(0),
+  });
+export interface AIThermistorVexChannel extends z.infer<
+  typeof aiThermistorVexChannelZ
+> {}
+
+/**
+ * AITorqueBridgePolynomialChannel reads torque from a bridge with polynomial
+ * calibration.
+ */
+export const aiTorqueBridgePolynomialChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(bridgeZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(bridgePolynomialZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_torque_bridge_polynomial"),
+    /** units are the units of the torque measurement. */
+    units: torqueUnitsZ.default("NewtonMeters"),
+    /** physicalUnits are the physical units of the polynomial calibration. */
+    physicalUnits: torqueUnitsZ.default("NewtonMeters"),
+  });
+export interface AITorqueBridgePolynomialChannel extends z.infer<
+  typeof aiTorqueBridgePolynomialChannelZ
+> {}
+
+/** AIVoltageRMSChannel reads RMS voltage. */
+export const aiVoltageRMSChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(terminalZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_voltage_rms"),
+  });
+export interface AIVoltageRMSChannel extends z.infer<typeof aiVoltageRMSChannelZ> {}
+
+/** AIVoltageWithExcitChannel reads a voltage with excitation. */
+export const aiVoltageWithExcitChannelZ = baseAIChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(terminalZ.shape)
+  .extend(voltageExcitationZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ai_voltage_with_excit"),
+    /** bridgeConfig selects the physical bridge wiring. */
+    bridgeConfig: bridgeConfigZ.default("FullBridge"),
+    /**
+     * scaledByExcitation is true when the excitation voltage is used to scale the
+     * reading.
+     */
+    scaledByExcitation: z.boolean().default(false),
+  });
+export interface AIVoltageWithExcitChannel extends z.infer<
+  typeof aiVoltageWithExcitChannelZ
+> {}
+
+export const AI_CHANNEL_TYPES = [
+  "ai_voltage",
+  "ai_accel",
+  "ai_bridge",
+  "ai_current",
+  "ai_force_bridge_table",
+  "ai_force_bridge_two_point_lin",
+  "ai_force_iepe",
+  "ai_microphone",
+  "ai_pressure_bridge_table",
+  "ai_pressure_bridge_two_point_lin",
+  "ai_resistance",
+  "ai_rtd",
+  "ai_strain_gauge",
+  "ai_temp_builtin",
+  "ai_thermocouple",
+  "ai_torque_bridge_table",
+  "ai_torque_bridge_two_point_lin",
+  "ai_velocity_iepe",
+  "ai_accel_4_wire_dc_voltage",
+  "ai_accel_charge",
+  "ai_charge",
+  "ai_current_rms",
+  "ai_force_bridge_polynomial",
+  "ai_freq_voltage",
+  "ai_pressure_bridge_polynomial",
+  "ai_thermistor_iex",
+  "ai_thermistor_vex",
+  "ai_torque_bridge_polynomial",
+  "ai_voltage_rms",
+  "ai_voltage_with_excit",
+] as const;
+export const aiChannelTypeZ = z.enum(AI_CHANNEL_TYPES);
+export type AIChannelType = z.infer<typeof aiChannelTypeZ>;
+
+/**
+ * AIChannel is a single NI analog input channel. The type field selects the measurement
+ * mode and the fields that accompany it.
+ */
+export const aiChannelZ = z.discriminatedUnion("type", [
+  aiVoltageChannelZ,
+  aiAccelChannelZ,
+  aiBridgeChannelZ,
+  aiCurrentChannelZ,
+  aiForceBridgeTableChannelZ,
+  aiForceBridgeTwoPointLinChannelZ,
+  aiForceIEPEChannelZ,
+  aiMicrophoneChannelZ,
+  aiPressureBridgeTableChannelZ,
+  aiPressureBridgeTwoPointLinChannelZ,
+  aiResistanceChannelZ,
+  aiRTDChannelZ,
+  aiStrainGaugeChannelZ,
+  aiTempBuiltinChannelZ,
+  aiThermocoupleChannelZ,
+  aiTorqueBridgeTableChannelZ,
+  aiTorqueBridgeTwoPointLinChannelZ,
+  aiVelocityIEPEChannelZ,
+  aiAccel4WireDCVoltageChannelZ,
+  aiAccelChargeChannelZ,
+  aiChargeChannelZ,
+  aiCurrentRMSChannelZ,
+  aiForceBridgePolynomialChannelZ,
+  aiFreqVoltageChannelZ,
+  aiPressureBridgePolynomialChannelZ,
+  aiThermistorIexChannelZ,
+  aiThermistorVexChannelZ,
+  aiTorqueBridgePolynomialChannelZ,
+  aiVoltageRMSChannelZ,
+  aiVoltageWithExcitChannelZ,
+]);
+export type AIChannel =
+  | AIVoltageChannel
+  | AIAccelChannel
+  | AIBridgeChannel
+  | AICurrentChannel
+  | AIForceBridgeTableChannel
+  | AIForceBridgeTwoPointLinChannel
+  | AIForceIEPEChannel
+  | AIMicrophoneChannel
+  | AIPressureBridgeTableChannel
+  | AIPressureBridgeTwoPointLinChannel
+  | AIResistanceChannel
+  | AIRTDChannel
+  | AIStrainGaugeChannel
+  | AITempBuiltinChannel
+  | AIThermocoupleChannel
+  | AITorqueBridgeTableChannel
+  | AITorqueBridgeTwoPointLinChannel
+  | AIVelocityIEPEChannel
+  | AIAccel4WireDCVoltageChannel
+  | AIAccelChargeChannel
+  | AIChargeChannel
+  | AICurrentRMSChannel
+  | AIForceBridgePolynomialChannel
+  | AIFreqVoltageChannel
+  | AIPressureBridgePolynomialChannel
+  | AIThermistorIexChannel
+  | AIThermistorVexChannel
+  | AITorqueBridgePolynomialChannel
+  | AIVoltageRMSChannel
+  | AIVoltageWithExcitChannel;
+
+export const AI_CHANNEL_SCHEMAS: {
+  [K in AIChannelType]: z.ZodType<Extract<AIChannel, { type: K }>>;
+} = {
+  ai_voltage: aiVoltageChannelZ,
+  ai_accel: aiAccelChannelZ,
+  ai_bridge: aiBridgeChannelZ,
+  ai_current: aiCurrentChannelZ,
+  ai_force_bridge_table: aiForceBridgeTableChannelZ,
+  ai_force_bridge_two_point_lin: aiForceBridgeTwoPointLinChannelZ,
+  ai_force_iepe: aiForceIEPEChannelZ,
+  ai_microphone: aiMicrophoneChannelZ,
+  ai_pressure_bridge_table: aiPressureBridgeTableChannelZ,
+  ai_pressure_bridge_two_point_lin: aiPressureBridgeTwoPointLinChannelZ,
+  ai_resistance: aiResistanceChannelZ,
+  ai_rtd: aiRTDChannelZ,
+  ai_strain_gauge: aiStrainGaugeChannelZ,
+  ai_temp_builtin: aiTempBuiltinChannelZ,
+  ai_thermocouple: aiThermocoupleChannelZ,
+  ai_torque_bridge_table: aiTorqueBridgeTableChannelZ,
+  ai_torque_bridge_two_point_lin: aiTorqueBridgeTwoPointLinChannelZ,
+  ai_velocity_iepe: aiVelocityIEPEChannelZ,
+  ai_accel_4_wire_dc_voltage: aiAccel4WireDCVoltageChannelZ,
+  ai_accel_charge: aiAccelChargeChannelZ,
+  ai_charge: aiChargeChannelZ,
+  ai_current_rms: aiCurrentRMSChannelZ,
+  ai_force_bridge_polynomial: aiForceBridgePolynomialChannelZ,
+  ai_freq_voltage: aiFreqVoltageChannelZ,
+  ai_pressure_bridge_polynomial: aiPressureBridgePolynomialChannelZ,
+  ai_thermistor_iex: aiThermistorIexChannelZ,
+  ai_thermistor_vex: aiThermistorVexChannelZ,
+  ai_torque_bridge_polynomial: aiTorqueBridgePolynomialChannelZ,
+  ai_voltage_rms: aiVoltageRMSChannelZ,
+  ai_voltage_with_excit: aiVoltageWithExcitChannelZ,
+};
+
+/** CIFrequencyChannel measures signal frequency. */
+export const ciFrequencyChannelZ = baseCIChannelZ
+  .extend(customScaleZ.shape)
+  .extend(minMaxValZ.shape)
+  .extend({
+    type: z.literal("ci_frequency"),
+    /** minVal is the minimum expected frequency. */
+    minVal: z.number().default(2),
+    /** maxVal is the maximum expected frequency. */
+    maxVal: z.number().default(100),
+    /** units are the units of the frequency measurement. */
+    units: ciFreqUnitsZ.default("Hz"),
+    /** edge selects the edge the counter responds to. */
+    edge: ciEdgeZ.default("Rising"),
+    /** measMethod selects the measurement method. */
+    measMethod: ciMeasMethodZ.default("DynamicAvg"),
+    /** measTime is the averaging window for high-frequency measurement, in seconds. */
+    measTime: z.number().default(0.000006),
+    /** divisor is the counter divisor for large-range measurement. */
+    divisor: z.int32().default(4),
+    /** terminal is the terminal the counter signal is wired to. */
+    terminal: z.string().default(""),
+  });
+export interface CIFrequencyChannel extends z.infer<typeof ciFrequencyChannelZ> {}
+
+/** CIEdgeCountChannel counts signal edges. */
+export const ciEdgeCountChannelZ = baseCIChannelZ.extend({
+  type: z.literal("ci_edge_count"),
+  /** activeEdge selects the edge that increments the count. */
+  activeEdge: ciEdgeZ.default("Rising"),
+  /** countDirection selects the direction the counter counts. */
+  countDirection: ciCountDirectionZ.default("CountUp"),
+  /** initialCount is the value the counter starts at. */
+  initialCount: z.number().default(0),
+  /** terminal is the terminal the counter signal is wired to. */
+  terminal: z.string().default(""),
+});
+export interface CIEdgeCountChannel extends z.infer<typeof ciEdgeCountChannelZ> {}
+
+/** CIPeriodChannel measures signal period. */
+export const ciPeriodChannelZ = baseCIChannelZ
+  .extend(customScaleZ.shape)
+  .extend(minMaxValZ.shape)
+  .extend({
+    type: z.literal("ci_period"),
+    /** minVal is the minimum expected period, in the selected units. */
+    minVal: z.number().default(0.000001),
+    /** maxVal is the maximum expected period, in the selected units. */
+    maxVal: z.number().default(0.1),
+    /** units are the units of the period measurement. */
+    units: ciTimeUnitsZ.default("Seconds"),
+    /** startingEdge selects the edge that starts a period measurement. */
+    startingEdge: ciEdgeZ.default("Rising"),
+    /** measMethod selects the measurement method. */
+    measMethod: ciMeasMethodZ.default("DynamicAvg"),
+    /** measTime is the averaging window for high-frequency measurement, in seconds. */
+    measTime: z.number().default(0.001),
+    /** divisor is the counter divisor for large-range measurement. */
+    divisor: z.int32().default(4),
+    /** terminal is the terminal the counter signal is wired to. */
+    terminal: z.string().default(""),
+  });
+export interface CIPeriodChannel extends z.infer<typeof ciPeriodChannelZ> {}
+
+/** CIPulseWidthChannel measures pulse width. */
+export const ciPulseWidthChannelZ = baseCIChannelZ
+  .extend(customScaleZ.shape)
+  .extend(minMaxValZ.shape)
+  .extend({
+    type: z.literal("ci_pulse_width"),
+    /** minVal is the minimum expected pulse width, in the selected units. */
+    minVal: z.number().default(0.000001),
+    /** maxVal is the maximum expected pulse width, in the selected units. */
+    maxVal: z.number().default(0.1),
+    /** units are the units of the pulse-width measurement. */
+    units: ciTimeUnitsZ.default("Seconds"),
+    /** startingEdge selects the edge that starts a pulse-width measurement. */
+    startingEdge: ciEdgeZ.default("Rising"),
+    /** terminal is the terminal the counter signal is wired to. */
+    terminal: z.string().default(""),
+  });
+export interface CIPulseWidthChannel extends z.infer<typeof ciPulseWidthChannelZ> {}
+
+/** CISemiPeriodChannel measures semi-period. */
+export const ciSemiPeriodChannelZ = baseCIChannelZ
+  .extend(customScaleZ.shape)
+  .extend(minMaxValZ.shape)
+  .extend({
+    type: z.literal("ci_semi_period"),
+    /** minVal is the minimum expected semi-period, in the selected units. */
+    minVal: z.number().default(0.000001),
+    /** maxVal is the maximum expected semi-period, in the selected units. */
+    maxVal: z.number().default(0.1),
+    /** units are the units of the semi-period measurement. */
+    units: ciTimeUnitsZ.default("Seconds"),
+    /** terminal is the terminal the counter signal is wired to. */
+    terminal: z.string().default(""),
+  });
+export interface CISemiPeriodChannel extends z.infer<typeof ciSemiPeriodChannelZ> {}
+
+/** CITwoEdgeSepChannel measures the separation between two edges. */
+export const ciTwoEdgeSepChannelZ = baseCIChannelZ
+  .extend(customScaleZ.shape)
+  .extend(minMaxValZ.shape)
+  .extend({
+    type: z.literal("ci_two_edge_sep"),
+    /** minVal is the minimum expected separation, in the selected units. */
+    minVal: z.number().default(0.000001),
+    /** maxVal is the maximum expected separation, in the selected units. */
+    maxVal: z.number().default(1),
+    /** units are the units of the two-edge-separation measurement. */
+    units: ciTimeUnitsZ.default("Seconds"),
+    /** firstEdge selects the edge that starts the measurement. */
+    firstEdge: ciEdgeZ.default("Rising"),
+    /** secondEdge selects the edge that stops the measurement. */
+    secondEdge: ciEdgeZ.default("Falling"),
+    /** firstTerminal is the terminal the first edge's signal is wired to. */
+    firstTerminal: z.string().default(""),
+    /** secondTerminal is the terminal the second edge's signal is wired to. */
+    secondTerminal: z.string().default(""),
+  });
+export interface CITwoEdgeSepChannel extends z.infer<typeof ciTwoEdgeSepChannelZ> {}
+
+/** CIVelocityLinearChannel measures linear velocity from an encoder. */
+export const ciVelocityLinearChannelZ = baseCIChannelZ
+  .extend(customScaleZ.shape)
+  .extend(minMaxValZ.shape)
+  .extend({
+    type: z.literal("ci_velocity_linear"),
+    /** minVal is the minimum expected velocity. */
+    minVal: z.number().default(0),
+    /** maxVal is the maximum expected velocity. */
+    maxVal: z.number().default(1),
+    /** units are the units of the velocity measurement. */
+    units: ciLinearVelocityUnitsZ.default("m/s"),
+    /** decodingType selects the encoder decoding type. */
+    decodingType: ciDecodingTypeZ.default("X4"),
+    /** distPerPulse is the linear distance per encoder pulse. */
+    distPerPulse: z.number().default(0.001),
+    /** terminalA is the terminal for encoder channel A. */
+    terminalA: z.string().default(""),
+    /** terminalB is the terminal for encoder channel B. */
+    terminalB: z.string().default(""),
+  });
+export interface CIVelocityLinearChannel extends z.infer<
+  typeof ciVelocityLinearChannelZ
+> {}
+
+/** CIVelocityAngularChannel measures angular velocity from an encoder. */
+export const ciVelocityAngularChannelZ = baseCIChannelZ
+  .extend(customScaleZ.shape)
+  .extend(minMaxValZ.shape)
+  .extend({
+    type: z.literal("ci_velocity_angular"),
+    /** minVal is the minimum expected velocity. */
+    minVal: z.number().default(0),
+    /** maxVal is the maximum expected velocity. */
+    maxVal: z.number().default(1),
+    /** units are the units of the velocity measurement. */
+    units: ciAngularVelocityUnitsZ.default("RPM"),
+    /** decodingType selects the encoder decoding type. */
+    decodingType: ciDecodingTypeZ.default("X4"),
+    /** pulsesPerRev is the number of encoder pulses per revolution. */
+    pulsesPerRev: z.number().default(24),
+    /** terminalA is the terminal for encoder channel A. */
+    terminalA: z.string().default(""),
+    /** terminalB is the terminal for encoder channel B. */
+    terminalB: z.string().default(""),
+  });
+export interface CIVelocityAngularChannel extends z.infer<
+  typeof ciVelocityAngularChannelZ
+> {}
+
+/** CIPositionLinearChannel measures linear position from an encoder. */
+export const ciPositionLinearChannelZ = baseCIChannelZ
+  .extend(customScaleZ.shape)
+  .extend(zIndexZ.shape)
+  .extend({
+    type: z.literal("ci_position_linear"),
+    /** units are the units of the position measurement. */
+    units: ciLinearPositionUnitsZ.default("Meters"),
+    /** decodingType selects the encoder decoding type. */
+    decodingType: ciDecodingTypeZ.default("X4"),
+    /** distPerPulse is the linear distance per encoder pulse. */
+    distPerPulse: z.number().default(0.000001),
+    /** initialPos is the position the encoder starts at. */
+    initialPos: z.number().default(0),
+    /** terminalA is the terminal for encoder channel A. */
+    terminalA: z.string().default(""),
+    /** terminalB is the terminal for encoder channel B. */
+    terminalB: z.string().default(""),
+  });
+export interface CIPositionLinearChannel extends z.infer<
+  typeof ciPositionLinearChannelZ
+> {}
+
+/** CIPositionAngularChannel measures angular position from an encoder. */
+export const ciPositionAngularChannelZ = baseCIChannelZ
+  .extend(customScaleZ.shape)
+  .extend(zIndexZ.shape)
+  .extend({
+    type: z.literal("ci_position_angular"),
+    /** units are the units of the position measurement. */
+    units: ciAngularPositionUnitsZ.default("Degrees"),
+    /** decodingType selects the encoder decoding type. */
+    decodingType: ciDecodingTypeZ.default("X4"),
+    /** pulsesPerRev is the number of encoder pulses per revolution. */
+    pulsesPerRev: z.number().default(24),
+    /** initialAngle is the angle the encoder starts at. */
+    initialAngle: z.number().default(0),
+    /** terminalA is the terminal for encoder channel A. */
+    terminalA: z.string().default(""),
+    /** terminalB is the terminal for encoder channel B. */
+    terminalB: z.string().default(""),
+  });
+export interface CIPositionAngularChannel extends z.infer<
+  typeof ciPositionAngularChannelZ
+> {}
+
+/** CIDutyCycleChannel measures the duty cycle of a signal. */
+export const ciDutyCycleChannelZ = baseCIChannelZ
+  .extend(customScaleZ.shape)
+  .extend(minMaxValZ.shape)
+  .extend({
+    type: z.literal("ci_duty_cycle"),
+    /** minVal is the minimum expected duty-cycle frequency. */
+    minVal: z.number().default(2),
+    /** maxVal is the maximum expected duty-cycle frequency. */
+    maxVal: z.number().default(10000),
+    /** activeEdge selects the edge the counter responds to. */
+    activeEdge: ciEdgeZ.default("Rising"),
+    /** terminal is the terminal the counter signal is wired to. */
+    terminal: z.string().default(""),
+  });
+export interface CIDutyCycleChannel extends z.infer<typeof ciDutyCycleChannelZ> {}
+
+export const CI_CHANNEL_TYPES = [
+  "ci_frequency",
+  "ci_edge_count",
+  "ci_period",
+  "ci_pulse_width",
+  "ci_semi_period",
+  "ci_two_edge_sep",
+  "ci_velocity_linear",
+  "ci_velocity_angular",
+  "ci_position_linear",
+  "ci_position_angular",
+  "ci_duty_cycle",
+] as const;
+export const ciChannelTypeZ = z.enum(CI_CHANNEL_TYPES);
+export type CIChannelType = z.infer<typeof ciChannelTypeZ>;
+
+/**
+ * CIChannel is a single NI counter input channel. The type field selects the
+ * measurement mode and the fields that accompany it.
+ */
+export const ciChannelZ = z.discriminatedUnion("type", [
+  ciFrequencyChannelZ,
+  ciEdgeCountChannelZ,
+  ciPeriodChannelZ,
+  ciPulseWidthChannelZ,
+  ciSemiPeriodChannelZ,
+  ciTwoEdgeSepChannelZ,
+  ciVelocityLinearChannelZ,
+  ciVelocityAngularChannelZ,
+  ciPositionLinearChannelZ,
+  ciPositionAngularChannelZ,
+  ciDutyCycleChannelZ,
+]);
+export type CIChannel =
+  | CIFrequencyChannel
+  | CIEdgeCountChannel
+  | CIPeriodChannel
+  | CIPulseWidthChannel
+  | CISemiPeriodChannel
+  | CITwoEdgeSepChannel
+  | CIVelocityLinearChannel
+  | CIVelocityAngularChannel
+  | CIPositionLinearChannel
+  | CIPositionAngularChannel
+  | CIDutyCycleChannel;
+
+export const CI_CHANNEL_SCHEMAS: {
+  [K in CIChannelType]: z.ZodType<Extract<CIChannel, { type: K }>>;
+} = {
+  ci_frequency: ciFrequencyChannelZ,
+  ci_edge_count: ciEdgeCountChannelZ,
+  ci_period: ciPeriodChannelZ,
+  ci_pulse_width: ciPulseWidthChannelZ,
+  ci_semi_period: ciSemiPeriodChannelZ,
+  ci_two_edge_sep: ciTwoEdgeSepChannelZ,
+  ci_velocity_linear: ciVelocityLinearChannelZ,
+  ci_velocity_angular: ciVelocityAngularChannelZ,
+  ci_position_linear: ciPositionLinearChannelZ,
+  ci_position_angular: ciPositionAngularChannelZ,
+  ci_duty_cycle: ciDutyCycleChannelZ,
+};
+
+/** AOCurrentChannel drives a current output. */
+export const aoCurrentChannelZ = baseAOChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ao_current"),
+  });
+export interface AOCurrentChannel extends z.infer<typeof aoCurrentChannelZ> {}
+
+/** AOFuncGenChannel drives a function-generator output. */
+export const aoFuncGenChannelZ = baseAOChannelZ.extend({
+  type: z.literal("ao_func_gen"),
+  /** waveType selects the waveform to generate. */
+  waveType: waveTypeZ.default("Sine"),
+  /** frequency is the waveform frequency, in Hertz. */
+  frequency: z.number().default(0),
+  /** amplitude is the waveform amplitude. */
+  amplitude: z.number().default(0),
+  /** offset is the waveform DC offset. */
+  offset: z.number().default(0),
+});
+export interface AOFuncGenChannel extends z.infer<typeof aoFuncGenChannelZ> {}
+
+/** AOVoltageChannel drives a voltage output. */
+export const aoVoltageChannelZ = baseAOChannelZ
+  .extend(minMaxValZ.shape)
+  .extend(customScaleZ.shape)
+  .extend({
+    type: z.literal("ao_voltage"),
+  });
+export interface AOVoltageChannel extends z.infer<typeof aoVoltageChannelZ> {}
+
+export const AO_CHANNEL_TYPES = ["ao_current", "ao_func_gen", "ao_voltage"] as const;
+export const aoChannelTypeZ = z.enum(AO_CHANNEL_TYPES);
+export type AOChannelType = z.infer<typeof aoChannelTypeZ>;
+
+/**
+ * AOChannel is a single NI analog output channel. The type field selects the output
+ * mode and the fields that accompany it.
+ */
+export const aoChannelZ = z.discriminatedUnion("type", [
+  aoCurrentChannelZ,
+  aoFuncGenChannelZ,
+  aoVoltageChannelZ,
+]);
+export type AOChannel = AOCurrentChannel | AOFuncGenChannel | AOVoltageChannel;
+
+export const AO_CHANNEL_SCHEMAS: {
+  [K in AOChannelType]: z.ZodType<Extract<AOChannel, { type: K }>>;
+} = {
+  ao_current: aoCurrentChannelZ,
+  ao_func_gen: aoFuncGenChannelZ,
+  ao_voltage: aoVoltageChannelZ,
+};
+
+export const analogReadConfigZ = task.readConfigZ.extend({
+  channels: aiChannelZ.array().default(() => []),
+});
+export interface AnalogReadConfig extends z.infer<typeof analogReadConfigZ> {}
+
+export const counterReadConfigZ = task.readConfigZ.extend({
+  channels: ciChannelZ.array().default(() => []),
+});
+export interface CounterReadConfig extends z.infer<typeof counterReadConfigZ> {}
+
+export const analogWriteConfigZ = writeConfigZ.extend({
+  channels: aoChannelZ.array().default(() => []),
+});
+export interface AnalogWriteConfig extends z.infer<typeof analogWriteConfigZ> {}