@typecad/hal 0.1.0-alpha.1

package/dist/i2c.js

@@ -0,0 +1,126 @@
+import { i2cBegin, i2cEnd, i2cSetClock, i2cBeginTx, i2cWrite, i2cWriteBuffer, i2cEndTx, i2cRequestFrom, i2cAvailable, i2cRead, rawCpp } from './emit.js';
+import { include } from './include.js';
+export class I2CDevice {
+    constructor(bus, address) {
+        this._bus = bus;
+        this._address = address;
+    }
+    writeByte(register, value) {
+        include("<Wire.h>");
+        i2cBeginTx(this._bus, this._address);
+        i2cWrite(this._bus, register);
+        i2cWrite(this._bus, value);
+        i2cEndTx(this._bus, true);
+    }
+    readByte(register) {
+        include("<Wire.h>");
+        i2cBeginTx(this._bus, this._address);
+        i2cWrite(this._bus, register);
+        i2cEndTx(this._bus, false);
+        i2cRequestFrom(this._bus, this._address, 1);
+        return i2cRead(this._bus);
+    }
+    writeBytes(register, data) {
+        include("<Wire.h>");
+        i2cBeginTx(this._bus, this._address);
+        i2cWrite(this._bus, register);
+        i2cWriteBuffer(this._bus, data);
+        i2cEndTx(this._bus, true);
+    }
+    readBytes(register, count) {
+        include("<Wire.h>");
+        i2cBeginTx(this._bus, this._address);
+        i2cWrite(this._bus, register);
+        i2cEndTx(this._bus, false);
+        i2cRequestFrom(this._bus, this._address, count, true);
+        rawCpp(`static uint8_t __buf[${count}];`);
+        rawCpp(`for (int __i = 0; __i < ${count}; __i++) __buf[__i] = ${this._bus}.read();`);
+        rawCpp(`return __buf;`);
+        return new Uint8Array(count);
+    }
+}
+export class I2CBus {
+    constructor(bus) {
+        this._bus = bus;
+    }
+    device(address) {
+        return new I2CDevice(this._bus, address);
+    }
+    begin() {
+        include("<Wire.h>");
+        i2cBegin(this._bus);
+        return this;
+    }
+    beginSlave(address) {
+        i2cBegin(this._bus, address);
+    }
+    end() {
+        i2cEnd(this._bus);
+    }
+    setClock(hz) {
+        i2cSetClock(this._bus, hz);
+    }
+    /** Recover a locked I2C bus by clocking SCL until the stuck slave releases SDA.
+     *
+     *  NOTE: This references the board-defined `SCL` pin macro. All current MCU
+     *  packages (atmega328p, esp32, esp32c3, esp32c6, esp32s3) export SCL, so
+     *  this works in practice. A fully portable version would resolve the SCL
+     *  pin number via a board constant (e.g. peripherals.i2c.0.sclPin), but that
+     *  requires adding resolved numeric pin fields to the board-constants
+     *  pipeline — deferred for now. */
+    recover() {
+        include("<Wire.h>");
+        rawCpp(`pinMode(SCL, OUTPUT);`);
+        rawCpp(`for (int i = 0; i < 16; i++) {`);
+        rawCpp(`  digitalWrite(SCL, LOW);`);
+        rawCpp(`  delayMicroseconds(10);`);
+        rawCpp(`  digitalWrite(SCL, HIGH);`);
+        rawCpp(`  delayMicroseconds(10);`);
+        rawCpp(`}`);
+        rawCpp(`${this._bus}.begin();`);
+    }
+    take() {
+        include("<Wire.h>");
+        return this;
+    }
+    release() {
+        // No-op for standard Arduino.
+    }
+    writeByte(address, register, value) {
+        i2cBeginTx(this._bus, address);
+        i2cWrite(this._bus, register);
+        i2cWrite(this._bus, value);
+        i2cEndTx(this._bus, true);
+    }
+    readByte(address, register) {
+        i2cBeginTx(this._bus, address);
+        i2cWrite(this._bus, register);
+        i2cEndTx(this._bus, false);
+        i2cRequestFrom(this._bus, address, 1);
+        return i2cRead(this._bus);
+    }
+    // Low-level Wire API pass-through methods
+    beginTransmission(address) {
+        i2cBeginTx(this._bus, address);
+    }
+    write(data) {
+        i2cWrite(this._bus, data);
+    }
+    endTransmission(stop) {
+        return i2cEndTx(this._bus, stop ?? true);
+    }
+    requestFrom(address, quantity, stop) {
+        return i2cRequestFrom(this._bus, address, quantity, stop ?? true);
+    }
+    available() {
+        return i2cAvailable(this._bus);
+    }
+    read() {
+        return i2cRead(this._bus);
+    }
+}
+I2CBus.__includes = ["<Wire.h>"];
+/** Map TypeCAD I2C instance number to Arduino C++ object name. I2C0→Wire, I2C1→Wire1 */
+export function i2cName(instance) {
+    return instance === 0 ? "Wire" : `Wire${instance}`;
+}

package/dist/include.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compile-time function: adds a C++ #include header to the generated output.
+ * At runtime (tests, type-checking) this is a no-op.
+ */
+export declare function include(_text: string): void;

package/dist/include.js

@@ -0,0 +1,5 @@
+/**
+ * Compile-time function: adds a C++ #include header to the generated output.
+ * At runtime (tests, type-checking) this is a no-op.
+ */
+export function include(_text) { }

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+export type { DigitalValue, AnalogValue } from './types.js';
+export { PinMode, InterruptMode } from './types.js';
+export type { IPinGroup, PinGroupMember } from './types.js';
+export { createPinGroup } from './types.js';
+export type { InterruptHandler } from './types.js';
+export type { ArchitectureIdentifier } from './types.js';
+export type { I2CAddress } from './types.js';
+export type { SPIBitOrder, SPIMode, SPISettings } from './types.js';
+export { include } from './include.js';
+export { board } from './board.js';
+export { callback } from './callback.js';
+export { rawCpp, boardResolve } from './emit.js';
+export { HIGH, LOW, OUTPUT, INPUT, INPUT_PULLUP, INPUT_PULLDOWN, OUTPUT_OPEN_DRAIN, ANALOG, LED_BUILTIN, LSBFIRST, MSBFIRST, WDTO_15MS, WDTO_30MS, WDTO_60MS, WDTO_120MS, WDTO_250MS, WDTO_500MS, WDTO_1S, WDTO_2S, WDTO_4S, WDTO_8S } from './constants.js';
+export { delay, millis, micros, delayMicroseconds, map, constrain, TimingClass, Timing } from './timing.js';
+export { freeHeap, setInterval, setTimeout, clearInterval, clearTimeout } from './timing.js';
+export { abs, min, max, NumClass, Num, MapChain, ConstrainChain } from './math.js';
+export { Pulse, pulseIn, pulseInLong } from './pulse.js';
+export { Shift, shiftIn, shiftOut } from './shift.js';
+export { Random } from './random.js';
+export { randomSeed, random } from './random.js';
+export { noInterrupts, interrupts, attachInterrupt, detachInterrupt } from './interrupts.js';
+export { Pin, OutputPin, InputPin, ToneChain } from './gpio.js';
+export { I2CBus, I2CDevice, i2cName } from './i2c.js';
+export { SPIBus, SPIDevice, spiName } from './spi.js';
+export { SerialPort, serialName } from './uart.js';
+export { createHALInstances } from './utils.js';
+export type { Bit, Bits } from './register.js';
+export { register, bits } from './register.js';
+export { EEPROMClass, EEPROM } from './eeprom.js';
+export { WDTClass, WDT } from './wdt.js';
+export { ADCClass, ADC } from './adc.js';
+export { DACClass, DAC } from './dac.js';
+export { PreferencesClass, Preferences } from './preferences.js';
+export { HardwareTimer, Timer0, Timer1, Timer2 } from './timer.js';
+export { FSClass, FS } from './fs.js';
+export { PowerClass, Power } from './power.js';
+export { AsyncClass, Async } from './async.js';

package/dist/index.js

@@ -0,0 +1,30 @@
+export { PinMode, InterruptMode } from './types.js';
+export { createPinGroup } from './types.js';
+export { include } from './include.js';
+export { board } from './board.js';
+export { callback } from './callback.js';
+export { rawCpp, boardResolve } from './emit.js';
+export { HIGH, LOW, OUTPUT, INPUT, INPUT_PULLUP, INPUT_PULLDOWN, OUTPUT_OPEN_DRAIN, ANALOG, LED_BUILTIN, LSBFIRST, MSBFIRST, WDTO_15MS, WDTO_30MS, WDTO_60MS, WDTO_120MS, WDTO_250MS, WDTO_500MS, WDTO_1S, WDTO_2S, WDTO_4S, WDTO_8S } from './constants.js';
+export { delay, millis, micros, delayMicroseconds, map, constrain, TimingClass, Timing } from './timing.js';
+export { freeHeap, setInterval, setTimeout, clearInterval, clearTimeout } from './timing.js';
+export { abs, min, max, NumClass, Num, MapChain, ConstrainChain } from './math.js';
+export { Pulse, pulseIn, pulseInLong } from './pulse.js';
+export { Shift, shiftIn, shiftOut } from './shift.js';
+export { Random } from './random.js';
+export { randomSeed, random } from './random.js';
+export { noInterrupts, interrupts, attachInterrupt, detachInterrupt } from './interrupts.js';
+export { Pin, OutputPin, InputPin, ToneChain } from './gpio.js';
+export { I2CBus, I2CDevice, i2cName } from './i2c.js';
+export { SPIBus, SPIDevice, spiName } from './spi.js';
+export { SerialPort, serialName } from './uart.js';
+export { createHALInstances } from './utils.js';
+export { register, bits } from './register.js';
+export { EEPROMClass, EEPROM } from './eeprom.js';
+export { WDTClass, WDT } from './wdt.js';
+export { ADCClass, ADC } from './adc.js';
+export { DACClass, DAC } from './dac.js';
+export { PreferencesClass, Preferences } from './preferences.js';
+export { HardwareTimer, Timer0, Timer1, Timer2 } from './timer.js';
+export { FSClass, FS } from './fs.js';
+export { PowerClass, Power } from './power.js';
+export { AsyncClass, Async } from './async.js';

package/dist/interrupts.d.ts

@@ -0,0 +1,17 @@
+import type { InterruptHandler, InterruptMode } from './types.js';
+/**
+ * Globally disable interrupts.
+ */
+export declare function noInterrupts(): void;
+/**
+ * Re-enable interrupts after `noInterrupts()`.
+ */
+export declare function interrupts(): void;
+/**
+ * Attach an interrupt handler to a pin.
+ */
+export declare function attachInterrupt(pin: number, handler: InterruptHandler, mode: InterruptMode): void;
+/**
+ * Detach a previously attached interrupt.
+ */
+export declare function detachInterrupt(pin: number): void;

package/dist/interrupts.js

@@ -0,0 +1,25 @@
+// ---------------------------------------------------------------------------
+// @typecad/hal — Interrupt helpers
+// ---------------------------------------------------------------------------
+import { interruptAttach, interruptDetach } from './emit.js';
+import { callback } from './callback.js';
+/**
+ * Globally disable interrupts.
+ */
+export function noInterrupts() { }
+/**
+ * Re-enable interrupts after `noInterrupts()`.
+ */
+export function interrupts() { }
+/**
+ * Attach an interrupt handler to a pin.
+ */
+export function attachInterrupt(pin, handler, mode) {
+    interruptAttach(pin, callback(handler), mode);
+}
+/**
+ * Detach a previously attached interrupt.
+ */
+export function detachInterrupt(pin) {
+    interruptDetach(pin);
+}

package/dist/math.d.ts

@@ -0,0 +1,22 @@
+export declare class MapChain {
+    constructor(value: number);
+    from(low: number, high: number): MapChain;
+    to(low: number, high: number): number;
+    toPercent(): number;
+    toByte(): number;
+}
+export declare class ConstrainChain {
+    constructor(value: number);
+    between(low: number, high: number): number;
+}
+export declare class NumClass {
+    abs(x: number): number;
+    min(a: number, b: number): number;
+    max(a: number, b: number): number;
+    constrain(value: number): ConstrainChain;
+    map(value: number): MapChain;
+}
+export declare const Num: NumClass;
+export declare function abs(x: number): number;
+export declare function min(a: number, b: number): number;
+export declare function max(a: number, b: number): number;

package/dist/math.js

@@ -0,0 +1,28 @@
+export class MapChain {
+    constructor(value) { }
+    from(low, high) { return this; }
+    to(low, high) { return 0; }
+    toPercent() { return 0; }
+    toByte() { return 0; }
+}
+export class ConstrainChain {
+    constructor(value) { }
+    between(low, high) { return 0; }
+}
+export class NumClass {
+    // No __instance_name — Num methods must NOT be intercepted by the HAL
+    // resolver. They pass through as bare C++ calls (Num.abs(-7)), which the
+    // strategy's __tc_Num polyfill struct provides. The strategy post-processes
+    // the output to rename Num.abs( → Num._abs( to match the polyfill's
+    // parenthesized method names (which avoid macro collisions with Arduino's
+    // abs/min/max macros). See strategy.ts __tc_Num struct + the rewrite regex.
+    abs(x) { return 0; }
+    min(a, b) { return 0; }
+    max(a, b) { return 0; }
+    constrain(value) { return new ConstrainChain(value); }
+    map(value) { return new MapChain(value); }
+}
+export const Num = new NumClass();
+export function abs(x) { return 0; }
+export function min(a, b) { return 0; }
+export function max(a, b) { return 0; }

package/dist/power.d.ts

@@ -0,0 +1,14 @@
+/**
+ * PowerClass provides control over MCU power states and clock frequencies.
+ *
+ * The arch guard (ESP32 family vs AVR) lives in the strategy, not here — it
+ * relies on the FQBN-derived architecture which is always available at
+ * transpile time, unlike `board("architecture")` which needs a board package.
+ */
+export declare class PowerClass {
+    static readonly __instance_name = "Power";
+    deepSleep(ms: number): void;
+    lightSleep(): void;
+    setCpuFrequency(mhz: number): void;
+}
+export declare const Power: PowerClass;

package/dist/power.js

@@ -0,0 +1,21 @@
+import { powerDeepSleep, powerLightSleep, powerSetCpuFrequency } from './emit.js';
+/**
+ * PowerClass provides control over MCU power states and clock frequencies.
+ *
+ * The arch guard (ESP32 family vs AVR) lives in the strategy, not here — it
+ * relies on the FQBN-derived architecture which is always available at
+ * transpile time, unlike `board("architecture")` which needs a board package.
+ */
+export class PowerClass {
+    deepSleep(ms) {
+        powerDeepSleep(ms);
+    }
+    lightSleep() {
+        powerLightSleep();
+    }
+    setCpuFrequency(mhz) {
+        powerSetCpuFrequency(mhz);
+    }
+}
+PowerClass.__instance_name = "Power";
+export const Power = new PowerClass();

package/dist/preferences.d.ts

@@ -0,0 +1,18 @@
+export declare class PreferencesClass {
+    static readonly __instance_name = "Preferences";
+    begin(name: string, readOnly?: boolean): void;
+    end(): void;
+    clear(): void;
+    remove(key: string): void;
+    putInt(key: string, value: number): void;
+    getInt(key: string, defaultValue?: number): number;
+    putUInt(key: string, value: number): void;
+    getUInt(key: string, defaultValue?: number): number;
+    putFloat(key: string, value: number): void;
+    getFloat(key: string, defaultValue?: number): number;
+    putBool(key: string, value: boolean): void;
+    getBool(key: string, defaultValue?: boolean): boolean;
+    putString(key: string, value: string): void;
+    getString(key: string, defaultValue?: string): string;
+}
+export declare const Preferences: PreferencesClass;

package/dist/preferences.js

@@ -0,0 +1,55 @@
+import { rawCpp } from './emit.js';
+export class PreferencesClass {
+    // NOTE: no __includes here. The transpiler emits singleton __includes on
+    // every architecture with no filtering, and <Preferences.h> is ESP32-only —
+    // adding it would break AVR builds. The class is ESP32-only by convention.
+    begin(name, readOnly = false) {
+        rawCpp(`Preferences.begin(${name}.c_str(), ${readOnly});`);
+    }
+    end() {
+        rawCpp(`Preferences.end();`);
+    }
+    clear() {
+        rawCpp(`Preferences.clear();`);
+    }
+    remove(key) {
+        rawCpp(`Preferences.remove(${key}.c_str());`);
+    }
+    putInt(key, value) {
+        rawCpp(`Preferences.putInt(${key}.c_str(), ${value});`);
+    }
+    getInt(key, defaultValue = 0) {
+        rawCpp(`return Preferences.getInt(${key}.c_str(), ${defaultValue});`);
+        return 0;
+    }
+    putUInt(key, value) {
+        rawCpp(`Preferences.putUInt(${key}.c_str(), ${value});`);
+    }
+    getUInt(key, defaultValue = 0) {
+        rawCpp(`return Preferences.getUInt(${key}.c_str(), ${defaultValue});`);
+        return 0;
+    }
+    putFloat(key, value) {
+        rawCpp(`Preferences.putFloat(${key}.c_str(), ${value});`);
+    }
+    getFloat(key, defaultValue = 0) {
+        rawCpp(`return Preferences.getFloat(${key}.c_str(), ${defaultValue});`);
+        return 0;
+    }
+    putBool(key, value) {
+        rawCpp(`Preferences.putBool(${key}.c_str(), ${value});`);
+    }
+    getBool(key, defaultValue = false) {
+        rawCpp(`return Preferences.getBool(${key}.c_str(), ${defaultValue});`);
+        return false;
+    }
+    putString(key, value) {
+        rawCpp(`Preferences.putString(${key}.c_str(), ${value}.c_str());`);
+    }
+    getString(key, defaultValue = "") {
+        rawCpp(`return Preferences.getString(${key}.c_str(), ${defaultValue}.c_str());`);
+        return "";
+    }
+}
+PreferencesClass.__instance_name = "Preferences";
+export const Preferences = new PreferencesClass();

package/dist/pulse.d.ts

@@ -0,0 +1,24 @@
+import type { Pin, InputPin } from './gpio.js';
+export declare function pulseIn(pin: number, value: number, timeout?: number): number;
+export declare function pulseInLong(pin: number, value: number, timeout?: number): number;
+export declare class Pulse {
+    /**
+     * Functional entrypoint for measuring pulses.
+     * @example Pulse.on(D7).high()
+     */
+    static on(pin: Pin | InputPin): PulseMeasurement;
+    /** Measure long pulses using high-precision 64-bit timers. */
+    static long(pin: Pin | InputPin, value: number): number;
+}
+declare class PulseMeasurement {
+    private _pin;
+    private _timeout;
+    constructor(pin: Pin | InputPin);
+    /** Set the maximum wait time for a pulse (in microseconds). */
+    timeout(us: number): this;
+    /** Measures the next HIGH pulse duration in microseconds. */
+    high(): number;
+    /** Measures the next LOW pulse duration in microseconds. */
+    low(): number;
+}
+export {};

package/dist/pulse.js

@@ -0,0 +1,53 @@
+import { rawCpp } from './emit.js';
+export function pulseIn(pin, value, timeout) {
+    if (timeout !== undefined) {
+        rawCpp(`return pulseIn(${pin}, ${value}, ${timeout});`);
+    }
+    else {
+        rawCpp(`return pulseIn(${pin}, ${value});`);
+    }
+    return 0;
+}
+export function pulseInLong(pin, value, timeout) {
+    if (timeout !== undefined) {
+        rawCpp(`return pulseInLong(${pin}, ${value}, ${timeout});`);
+    }
+    else {
+        rawCpp(`return pulseInLong(${pin}, ${value});`);
+    }
+    return 0;
+}
+export class Pulse {
+    /**
+     * Functional entrypoint for measuring pulses.
+     * @example Pulse.on(D7).high()
+     */
+    static on(pin) {
+        return new PulseMeasurement(pin);
+    }
+    /** Measure long pulses using high-precision 64-bit timers. */
+    static long(pin, value) {
+        rawCpp(`return pulseInLong(${pin.number}, ${value});`);
+        return 0;
+    }
+}
+class PulseMeasurement {
+    constructor(pin) {
+        this._pin = pin.number;
+    }
+    /** Set the maximum wait time for a pulse (in microseconds). */
+    timeout(us) {
+        this._timeout = us;
+        return this;
+    }
+    /** Measures the next HIGH pulse duration in microseconds. */
+    high() {
+        rawCpp(`return pulseIn(${this._pin}, HIGH${this._timeout !== undefined ? `, ${this._timeout}` : ""});`);
+        return 0;
+    }
+    /** Measures the next LOW pulse duration in microseconds. */
+    low() {
+        rawCpp(`return pulseIn(${this._pin}, LOW${this._timeout !== undefined ? `, ${this._timeout}` : ""});`);
+        return 0;
+    }
+}

package/dist/random.d.ts

@@ -0,0 +1,12 @@
+export declare function randomSeed(seed: number): void;
+export declare function random(minOrMax: number, max?: number): number;
+export declare class Random {
+    /** Seeds the PRNG with a starting value. */
+    static seed(val: number): void;
+    /** Returns a random number in range [0, max-1]. */
+    static upTo(max: number): number;
+    /** Returns a random number in range [min, max-1]. */
+    static between(min: number, max: number): number;
+    /** Returns a random non-negative 31-bit integer [0, 2147483646]. */
+    static int(): number;
+}

package/dist/random.js

@@ -0,0 +1,26 @@
+import { rawCpp } from './emit.js';
+export function randomSeed(seed) { }
+export function random(minOrMax, max) { return 0; }
+export class Random {
+    /** Seeds the PRNG with a starting value. */
+    static seed(val) {
+        rawCpp(`randomSeed(${val});`);
+    }
+    /** Returns a random number in range [0, max-1]. */
+    static upTo(max) {
+        rawCpp(`return random(${max});`);
+        return 0;
+    }
+    /** Returns a random number in range [min, max-1]. */
+    static between(min, max) {
+        rawCpp(`return random(${min}, ${max});`);
+        return 0;
+    }
+    /** Returns a random non-negative 31-bit integer [0, 2147483646]. */
+    static int() {
+        // Arduino random(max) returns [0, max-1]; 2147483647 = INT_MAX gives a
+        // non-negative 31-bit range (sign bit always 0).
+        rawCpp(`return random(2147483647);`);
+        return 0;
+    }
+}

package/dist/register.d.ts

@@ -0,0 +1,11 @@
+/** A single-bit register field (0 or 1). */
+export type Bit = 0 | 1;
+/** A multi-bit register field spanning N bits. The numeric type arg carries
+ *  the bit width for documentation only; the value is the raw field contents. */
+export type Bits<N extends number = number> = number;
+/** Class decorator marking a struct as a memory-mapped register at `address`.
+ *  Erased at transpile time — the class becomes a `volatile uint32_t*`. */
+export declare function register(address: number): ClassDecorator;
+/** Property decorator carrying the bit range [lo, hi] (inclusive) of a field
+ *  within its register. Erased at transpile time. */
+export declare function bits(hi: number, lo: number): PropertyDecorator;

package/dist/register.js

@@ -0,0 +1,21 @@
+// ---------------------------------------------------------------------------
+// Register-mapped struct decorators — compile-time markers
+//
+// `@register(address)` and `@bits(hi, lo)` are recognized by-name by the
+// cuttlefish transpiler (packages/cuttlefish/src/ir/register-decorators.ts).
+// The transpiler intercepts a class carrying @register, lowers it to a
+// `volatile uint32_t*` pointer at the given address, and rewrites field
+// reads/writes to shift/mask arithmetic. The decorators themselves are erased
+// and never execute, so these are ambient stubs that exist purely so user code
+// type-checks under tsc before transpilation.
+//
+//   @register(0x40011000)
+//   class USART1 {
+//     @bits(0, 0)  static UE:   Bit       = 0;
+//     @bits(9, 8)  static PS:   Bits<2>   = 0;
+//     @bits(15, 8) static BAUD: Bits<8>   = 0;
+//   }
+//   USART1.UE = 1;              // (*USART1 & ~1UL) | ((1 & 1UL) << 0)
+//   const parity = USART1.PS;   // ((*USART1 >> 8) & ((1UL << 2) - 1))
+// ---------------------------------------------------------------------------
+export {};

package/dist/shift.d.ts

@@ -0,0 +1,31 @@
+import type { Pin, OutputPin, InputPin } from './gpio.js';
+export declare function shiftIn(dataPin: number, clockPin: number, bitOrder: number): number;
+export declare function shiftOut(dataPin: number, clockPin: number, bitOrder: number, value: number): void;
+export declare class Shift {
+    /** Directly shifts a byte out to a pin. */
+    static out(dataPin: Pin | OutputPin, clockPin: Pin | OutputPin, order: 'lsb' | 'msb', value: number): void;
+    /** Directly shifts a byte in from a pin. */
+    static in(dataPin: Pin | InputPin, clockPin: Pin | OutputPin, order: 'lsb' | 'msb'): number;
+    /** Fluent builder for shifting out. */
+    static write(dataPin: Pin | OutputPin, value: number): ShiftOutBuilder;
+    /** Fluent builder for shifting in. */
+    static read(dataPin: Pin | InputPin): ShiftInBuilder;
+}
+declare class ShiftOutBuilder {
+    private _dataPin;
+    private _value;
+    private _clockPin;
+    constructor(dataPin: Pin | OutputPin, value: number);
+    clock(clk: Pin | OutputPin): this;
+    msbFirst(): void;
+    lsbFirst(): void;
+}
+declare class ShiftInBuilder {
+    private _dataPin;
+    private _clockPin;
+    constructor(dataPin: Pin | InputPin);
+    clock(clk: Pin | OutputPin): this;
+    msbFirst(): number;
+    lsbFirst(): number;
+}
+export {};