@typecad/hal 0.1.0-alpha.2 → 1.0.0-alpha.10

package/README.md

@@ -1,8 +1,8 @@
 # `@typecad/hal`
 
-Hardware abstraction layer for [TypeCAD](https://github.com/justind000/typecode) —
-GPIO, I2C, SPI, UART, timers, ADC/DAC, EEPROM, and more, written as regular
-TypeScript.
+Hardware abstraction layer for [TypeCAD](https://cuttlefish.typecad.net) —
+GPIO, I2C, SPI, UART, timers, ADC/DAC, EEPROM, WiFi/HTTP, and more, written as
+regular TypeScript.
 
 `@typecad/hal` is what firmware code imports to talk to hardware. You write
 normal TypeScript (`pin.high()`, `i2c.write(...)`, `Serial0.print(...)`); the
@@ -41,6 +41,7 @@ add new HAL features.
 | **I2C** | `I2CBus`, `II2CBus`, `I2CStatus`, `i2cName` |
 | **SPI** | `SPIBus`, `ISPIBus`, `SPIStatus`, `SPISettings`, `spiName` |
 | **UART / Serial** | `SerialPort`, `IUARTBus`, `UARTStatus`, `serialName` |
+| **Networking** | `WiFi`, `WiFiClass`, `WiFiStatus`, `WiFiEncryption`, `Http`, `HttpClass`, `HttpRequest`, `HttpMethod` |
 | **Timing** | `delay`, `millis`, `micros`, `delayMicroseconds`, `Timing`, `map`, `constrain` |
 | **Pulse / Shift** | `pulseIn`, `shiftIn`, `shiftOut` |
 | **Interrupts** | `attachInterrupt`, `detachInterrupt`, `noInterrupts`, `interrupts`, `InterruptMode` |
@@ -77,7 +78,7 @@ For I2C/SPI/UART, instantiate the bus class with the board's pinned instance
 
 The [`tests/`](./tests/) directory contains a hardware test suite that
 exercises every AVR-compilable HAL subsystem against real Arduino Uno hardware,
-using [`@typecad/expect`](https://github.com/justind000/typecode/tree/main/packages/expect)
+using [`@typecad/expect`](https://cuttlefish.typecad.net)
 (`describe()` / `.it()` / `.expect()` / `done()`) over serial. Each file covers
 one subsystem: GPIO, timing, math, random, pulse, shift, interrupts, UART,
 I2C, SPI, ADC, EEPROM, WDT, Preferences, async, and constants.
@@ -92,7 +93,7 @@ npm exec --workspace @typecad/hal -- cuttlefish-test
 ```
 
 The suite is configured by [`cuttlefish.config.ts`](./cuttlefish.config.ts).
-Like the [`@typecad/framework-arduino`](https://github.com/justind000/typecode/tree/main/packages/framework-arduino/tests)
+Like the [`@typecad/framework-arduino`](https://cuttlefish.typecad.net)
 tests, it imports through `@typecad/board` (the board package) and ambient globals
 declared in `cuttlefish-env.d.ts`, never directly from `@typecad/board`, so the
 transpiler resolves each call against the active MCU/board packages.
@@ -117,8 +118,8 @@ entirely — they require an ESP32 target.
 
 ## Ecosystem
 
-- [`@typecad/cuttlefish`](https://github.com/justind000/typecode/tree/main/packages/cuttlefish) — the transpiler that resolves HAL calls to C++.
-- [`@typecad/ui`](https://github.com/justind000/typecode/tree/main/packages/ui) — HTML/CSS-driven display graphics.
+- [`@typecad/cuttlefish`](https://cuttlefish.typecad.net) — the transpiler that resolves HAL calls to C++.
+- [`@typecad/ui`](https://cuttlefish.typecad.net) — HTML/CSS-driven display graphics.
 - `@typecad/mcu-*` — silicon pin/port/peripheral definitions.
 - `@typecad/board-*` — board-level pin mappings and bus aliases.
 

package/dist/ble.d.ts

@@ -0,0 +1,160 @@
+/** Characteristic value encoding — drives both TS callback types and C++ marshalling. */
+export declare enum BleValueType {
+    Uint8 = "uint8",
+    Uint16 = "uint16",
+    Uint32 = "uint32",
+    Int8 = "int8",
+    Int16 = "int16",
+    Int32 = "int32",
+    Float32 = "float32",
+    Utf8 = "utf8",
+    Boolean = "boolean",
+    Bytes = "bytes"
+}
+/** GATT characteristic permission flags. Combine with `|`. */
+export declare enum BlePerm {
+    Read = 1,
+    Write = 2,
+    Notify = 4
+}
+/** BLE peripheral status (mirrored by the runtime shim). */
+export declare enum BleStatus {
+    Idle = 0,
+    Initializing = 1,
+    Advertising = 2,
+    Connected = 3,
+    Error = 4
+}
+export declare enum BleAdvertisingMode {
+    Connectable = "connectable",
+    NonConnectable = "non_connectable"
+}
+/** A well-known GATT characteristic entry in the catalog. */
+export interface GattCharacteristicDef {
+    readonly uuid: string;
+    readonly type: BleValueType;
+    readonly read?: boolean;
+    readonly write?: boolean;
+    readonly notify?: boolean;
+}
+/**
+ * Standard GATT services/characteristics. Autocomplete walks the hierarchy:
+ *   GATT.ENVIRONMENTAL. -> TEMPERATURE, HUMIDITY, ...
+ * Pass the .uuid, .type, and computed perms to BleServer.characteristic().
+ */
+export declare const GATT: {
+    readonly DEVICE_INFO: {
+        readonly MANUFACTURER_NAME: {
+            readonly uuid: "2A29";
+            readonly type: BleValueType.Utf8;
+            readonly read: true;
+        };
+        readonly MODEL_NUMBER: {
+            readonly uuid: "2A24";
+            readonly type: BleValueType.Utf8;
+            readonly read: true;
+        };
+        readonly FIRMWARE_REVISION: {
+            readonly uuid: "2A26";
+            readonly type: BleValueType.Utf8;
+            readonly read: true;
+        };
+    };
+    readonly ENVIRONMENTAL: {
+        readonly TEMPERATURE: {
+            readonly uuid: "2A6E";
+            readonly type: BleValueType.Int16;
+            readonly read: true;
+            readonly notify: true;
+        };
+        readonly HUMIDITY: {
+            readonly uuid: "2A6F";
+            readonly type: BleValueType.Uint16;
+            readonly read: true;
+            readonly notify: true;
+        };
+        readonly PRESSURE: {
+            readonly uuid: "2A6D";
+            readonly type: BleValueType.Uint32;
+            readonly read: true;
+            readonly notify: true;
+        };
+    };
+    readonly BATTERY: {
+        readonly LEVEL: {
+            readonly uuid: "2A19";
+            readonly type: BleValueType.Uint8;
+            readonly read: true;
+            readonly notify: true;
+        };
+    };
+};
+/** The value passed to/from callbacks — narrowed per characteristic by type. */
+export type CharValue = number | string | boolean | Uint8Array;
+/**
+ * BLE GATT peripheral control, lowered to native ESP-IDF NimBLE
+ * (`nimble_host` / `ble_gap` / `ble_gatts`) by framework-esp32.
+ *
+ * No `include()` calls here — NimBLE headers are framework-owned and added via
+ * forcedIncludes when the program uses ble.* ops.
+ *
+ * Transpiler note: method bodies pass parameters directly into semantic calls
+ * (no local consts / module counters) so the resolver can statically track every
+ * argument. The characteristic index is carried through the chain via
+ * `this._charCount` fieldValues, mirroring how HttpRequest carries _method/_url.
+ */
+export declare class BleClass {
+    static readonly __instance_name = "Ble";
+    /** Begin building a GATT server with the given advertised device name. */
+    server(name: string): BleServer;
+    /** Initialize NimBLE, register services, and start advertising. */
+    begin(): void;
+    advertise(): void;
+    stopAdvertising(): void;
+    /** Blocking at top level; cooperatively awaitable inside async functions. */
+    untilConnected(timeoutMs?: number): Promise<boolean>;
+    untilConnectedStart(): void;
+    isConnected(): boolean;
+    status(): BleStatus;
+    clientCount(): number;
+    txPower(dbm: number): this;
+    notify(index: number, value: number): void;
+}
+/**
+ * Fluent GATT server builder. Returned by `Ble.server()`.
+ *
+ * Single-class fluent chain (like HttpRequest): characteristic() returns `this`,
+ * so onRead/onWrite/onSubscribe chain directly. The _charCount field tracks
+ * which characteristic slot the callbacks attach to.
+ *
+ * Field tracking (read by the transpiler resolver via ctor field assignment):
+ *   _name      — advertised device name
+ *   _charCount — current characteristic index (the last characteristic() target)
+ *   _svcCount  — current service index
+ */
+export declare class BleServer {
+    private _name;
+    private _charCount;
+    private _lastChar;
+    private _svcCount;
+    constructor(name: string, charCount: number, svcCount: number);
+    /** Add a characteristic by UUID, value type, and permissions.
+     *  Combine permissions with `|`: `BlePerm.Read | BlePerm.Notify`.
+     *  Returns this for chaining. */
+    characteristic(uuid: string, type: BleValueType, perms: number): this;
+    /** Begin a new service grouping. Subsequent characteristics attach to it. */
+    service(uuid: string): this;
+    /** Register a read handler for the most recently added characteristic. */
+    onRead(handler: () => CharValue): this;
+    /** Register a write handler for the most recently added characteristic. */
+    onWrite(handler: (value: number) => void): this;
+    /** Register a connect handler (called when a central connects). */
+    onConnect(handler: () => void): this;
+    /** Register a disconnect handler (called when a central disconnects). */
+    onDisconnect(handler: () => void): this;
+    /** Push a new value to subscribed clients on the most recently added characteristic. */
+    notify(value: number): void;
+    /** Initialize NimBLE, register services, and start advertising. */
+    begin(): void;
+}
+export declare const Ble: BleClass;

package/dist/ble.js

@@ -0,0 +1,157 @@
+import { bleServerBegin, bleAdvertiseStart, bleAdvertiseStop, bleAddService, bleAddChar, bleOnRead, bleOnWrite, bleOnConnect, bleOnDisconnect, bleNotify, bleIsConnected, bleClientCount, bleSetName, bleUntilConnected, bleUntilConnectedStart, bleSetTxPower, bleStatus, } from './emit.js';
+import { callback } from './callback.js';
+/** Characteristic value encoding — drives both TS callback types and C++ marshalling. */
+export var BleValueType;
+(function (BleValueType) {
+    BleValueType["Uint8"] = "uint8";
+    BleValueType["Uint16"] = "uint16";
+    BleValueType["Uint32"] = "uint32";
+    BleValueType["Int8"] = "int8";
+    BleValueType["Int16"] = "int16";
+    BleValueType["Int32"] = "int32";
+    BleValueType["Float32"] = "float32";
+    BleValueType["Utf8"] = "utf8";
+    BleValueType["Boolean"] = "boolean";
+    BleValueType["Bytes"] = "bytes";
+})(BleValueType || (BleValueType = {}));
+/** GATT characteristic permission flags. Combine with `|`. */
+export var BlePerm;
+(function (BlePerm) {
+    BlePerm[BlePerm["Read"] = 1] = "Read";
+    BlePerm[BlePerm["Write"] = 2] = "Write";
+    BlePerm[BlePerm["Notify"] = 4] = "Notify";
+})(BlePerm || (BlePerm = {}));
+/** BLE peripheral status (mirrored by the runtime shim). */
+export var BleStatus;
+(function (BleStatus) {
+    BleStatus[BleStatus["Idle"] = 0] = "Idle";
+    BleStatus[BleStatus["Initializing"] = 1] = "Initializing";
+    BleStatus[BleStatus["Advertising"] = 2] = "Advertising";
+    BleStatus[BleStatus["Connected"] = 3] = "Connected";
+    BleStatus[BleStatus["Error"] = 4] = "Error";
+})(BleStatus || (BleStatus = {}));
+export var BleAdvertisingMode;
+(function (BleAdvertisingMode) {
+    BleAdvertisingMode["Connectable"] = "connectable";
+    BleAdvertisingMode["NonConnectable"] = "non_connectable";
+})(BleAdvertisingMode || (BleAdvertisingMode = {}));
+/**
+ * Standard GATT services/characteristics. Autocomplete walks the hierarchy:
+ *   GATT.ENVIRONMENTAL. -> TEMPERATURE, HUMIDITY, ...
+ * Pass the .uuid, .type, and computed perms to BleServer.characteristic().
+ */
+export const GATT = {
+    DEVICE_INFO: {
+        MANUFACTURER_NAME: { uuid: '2A29', type: BleValueType.Utf8, read: true },
+        MODEL_NUMBER: { uuid: '2A24', type: BleValueType.Utf8, read: true },
+        FIRMWARE_REVISION: { uuid: '2A26', type: BleValueType.Utf8, read: true },
+    },
+    ENVIRONMENTAL: {
+        TEMPERATURE: { uuid: '2A6E', type: BleValueType.Int16, read: true, notify: true },
+        HUMIDITY: { uuid: '2A6F', type: BleValueType.Uint16, read: true, notify: true },
+        PRESSURE: { uuid: '2A6D', type: BleValueType.Uint32, read: true, notify: true },
+    },
+    BATTERY: {
+        LEVEL: { uuid: '2A19', type: BleValueType.Uint8, read: true, notify: true },
+    },
+};
+/**
+ * BLE GATT peripheral control, lowered to native ESP-IDF NimBLE
+ * (`nimble_host` / `ble_gap` / `ble_gatts`) by framework-esp32.
+ *
+ * No `include()` calls here — NimBLE headers are framework-owned and added via
+ * forcedIncludes when the program uses ble.* ops.
+ *
+ * Transpiler note: method bodies pass parameters directly into semantic calls
+ * (no local consts / module counters) so the resolver can statically track every
+ * argument. The characteristic index is carried through the chain via
+ * `this._charCount` fieldValues, mirroring how HttpRequest carries _method/_url.
+ */
+export class BleClass {
+    /** Begin building a GATT server with the given advertised device name. */
+    server(name) {
+        bleSetName(name);
+        return new BleServer(name, 0, 1);
+    }
+    /** Initialize NimBLE, register services, and start advertising. */
+    begin() {
+        bleServerBegin("TypeCAD");
+        bleAdvertiseStart();
+    }
+    advertise() { bleAdvertiseStart(); }
+    stopAdvertising() { bleAdvertiseStop(); }
+    /** Blocking at top level; cooperatively awaitable inside async functions. */
+    untilConnected(timeoutMs = 0) {
+        bleUntilConnected(timeoutMs);
+        return Promise.resolve(false);
+    }
+    untilConnectedStart() { bleUntilConnectedStart(); }
+    isConnected() { return bleIsConnected(); }
+    status() { return bleStatus(); }
+    clientCount() { return bleClientCount(); }
+    txPower(dbm) { bleSetTxPower(dbm); return this; }
+    notify(index, value) { bleNotify(index, value); }
+}
+BleClass.__instance_name = "Ble";
+/**
+ * Fluent GATT server builder. Returned by `Ble.server()`.
+ *
+ * Single-class fluent chain (like HttpRequest): characteristic() returns `this`,
+ * so onRead/onWrite/onSubscribe chain directly. The _charCount field tracks
+ * which characteristic slot the callbacks attach to.
+ *
+ * Field tracking (read by the transpiler resolver via ctor field assignment):
+ *   _name      — advertised device name
+ *   _charCount — current characteristic index (the last characteristic() target)
+ *   _svcCount  — current service index
+ */
+export class BleServer {
+    constructor(name, charCount, svcCount) {
+        this._name = name;
+        this._charCount = charCount;
+        this._lastChar = charCount;
+        this._svcCount = svcCount;
+    }
+    /** Add a characteristic by UUID, value type, and permissions.
+     *  Combine permissions with `|`: `BlePerm.Read | BlePerm.Notify`.
+     *  Returns this for chaining. */
+    characteristic(uuid, type, perms) {
+        bleAddChar(this._charCount, uuid, type, perms, this._svcCount);
+        return this;
+    }
+    /** Begin a new service grouping. Subsequent characteristics attach to it. */
+    service(uuid) {
+        bleAddService(uuid);
+        return this;
+    }
+    /** Register a read handler for the most recently added characteristic. */
+    onRead(handler) {
+        bleOnRead(this._lastChar, callback(handler));
+        return this;
+    }
+    /** Register a write handler for the most recently added characteristic. */
+    onWrite(handler) {
+        bleOnWrite(this._lastChar, callback(handler));
+        return this;
+    }
+    /** Register a connect handler (called when a central connects). */
+    onConnect(handler) {
+        bleOnConnect(callback(handler));
+        return this;
+    }
+    /** Register a disconnect handler (called when a central disconnects). */
+    onDisconnect(handler) {
+        bleOnDisconnect(callback(handler));
+        return this;
+    }
+    /** Push a new value to subscribed clients on the most recently added characteristic. */
+    notify(value) {
+        bleNotify(this._lastChar, value);
+    }
+    /** Initialize NimBLE, register services, and start advertising. */
+    begin() {
+        bleServerBegin(this._name);
+        bleAdvertiseStart();
+    }
+}
+export const Ble = new BleClass();

package/dist/capacitive.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CapacitiveClass — ESP32 on-chip capacitive touch pins.
+ *
+ * ESP32-family chips have dedicated capacitive-sensing GPIOs (10 on classic
+ * ESP32, up to 14 on S3) that read touch/proximity without external
+ * components — distinct from the I2C/SPI touch *display* controllers (FT6336U,
+ * GT911, etc.). Lowered to capacitive.* HAL ops: ESP-IDF's touch_sensor driver.
+ *
+ * Pin numbers are the touch-pad-capable GPIOs (GPIO4, GPIO0, GPIO2, ... on
+ * classic ESP32); the framework maps them to touch_channel indices.
+ */
+export declare class CapacitiveClass {
+    static readonly __instance_name = "Capacitive";
+    /** Read the raw capacitive value of a touch pin. Higher = more capacitance
+     *  (touched). The raw scale is chip-dependent; use a threshold calibrated
+     *  against the untouched reading. */
+    read(pin: number): number;
+    /** True when the pin's reading exceeds `threshold` (a convenience over read()). */
+    isTouched(pin: number, threshold: number): boolean;
+}
+export declare const Capacitive: CapacitiveClass;
+export declare function capacitiveRead(pin: number): number;

package/dist/capacitive.js

@@ -0,0 +1,27 @@
+/**
+ * CapacitiveClass — ESP32 on-chip capacitive touch pins.
+ *
+ * ESP32-family chips have dedicated capacitive-sensing GPIOs (10 on classic
+ * ESP32, up to 14 on S3) that read touch/proximity without external
+ * components — distinct from the I2C/SPI touch *display* controllers (FT6336U,
+ * GT911, etc.). Lowered to capacitive.* HAL ops: ESP-IDF's touch_sensor driver.
+ *
+ * Pin numbers are the touch-pad-capable GPIOs (GPIO4, GPIO0, GPIO2, ... on
+ * classic ESP32); the framework maps them to touch_channel indices.
+ */
+export class CapacitiveClass {
+    /** Read the raw capacitive value of a touch pin. Higher = more capacitance
+     *  (touched). The raw scale is chip-dependent; use a threshold calibrated
+     *  against the untouched reading. */
+    read(pin) {
+        return capacitiveRead(pin);
+    }
+    /** True when the pin's reading exceeds `threshold` (a convenience over read()). */
+    isTouched(pin, threshold) {
+        return capacitiveRead(pin) > threshold;
+    }
+}
+CapacitiveClass.__instance_name = "Capacitive";
+export const Capacitive = new CapacitiveClass();
+// ── Semantic primitive (resolved to capacitive.* HAL op by the transpiler) ──
+export function capacitiveRead(pin) { return 0; }

package/dist/emit.d.ts

@@ -8,6 +8,31 @@ export declare function gpioToggle(pin: number | string): void;
 export declare function gpioSetMode(pin: number | string, mode: string): void;
 /** Write PWM duty cycle to a pin. */
 export declare function pwmWrite(pin: number | string, duty: number): void;
+import type { Pin } from './gpio.js';
+type RmtPin = Pin | number | string;
+/** Positional semantic primitive. Args: pin, resolutionHz, bit0Hi, bit0Lo,
+ *  bit1Hi, bit1Lo, msbFirst, queueDepth. Use rmtTxInit() from hal/rmt.ts. */
+export declare function rmtTxInit(pin: RmtPin, resolutionHz: number, bit0Hi: number, bit0Lo: number, bit1Hi: number, bit1Lo: number, msbFirst: boolean, queueDepth: number): void;
+/** Write bytes via the channel's bytes-encoder (timings fixed at init). */
+export declare function rmtTxWriteBytes(pin: RmtPin, bytes: number[] | Uint8Array): void;
+/** Write raw RMT symbols — arbitrary [hiTicks, loTicks] pairs. */
+export declare function rmtTxWriteSymbols(pin: RmtPin, symbols: [number, number][]): void;
+/** Block until the queued TX completes. */
+export declare function rmtTxWaitDone(pin: RmtPin, timeoutMs?: number): void;
+/** Tear down the TX channel and release its slot. */
+export declare function rmtTxDeinit(pin: RmtPin): void;
+/** Positional semantic primitive — use rmtRxInit() from hal/rmt.ts. */
+export declare function rmtRxInit(pin: RmtPin, resolutionHz: number): void;
+/** Register a callback-by-name invoked when an RX burst completes. */
+export declare function rmtRxOnReceived(pin: RmtPin, handler: string): void;
+/** Start receiving. */
+export declare function rmtRxStart(pin: RmtPin): void;
+/** Stop receiving. */
+export declare function rmtRxStop(pin: RmtPin): void;
+/** Blocking read — returns flattened symbols [d0,l0,d1,l1,…] in ticks. */
+export declare function rmtRxRead(pin: RmtPin, maxCount: number): number[];
+/** Tear down the RX channel and release its slot. */
+export declare function rmtRxDeinit(pin: RmtPin): void;
 /** Read analog value from a pin. */
 export declare function adcRead(pin: number | string): number;
 /** Read analog voltage from a pin (ADC value converted to voltage). */
@@ -53,6 +78,15 @@ export declare function i2cRequestFrom(bus: string, address: number, quantity: n
 export declare function i2cAvailable(bus: string): number;
 /** Read a byte from I2C. */
 export declare function i2cRead(bus: string): number;
+/**
+ * Drain `count` bytes requested from the I2C bus into a caller-provided buffer.
+ * Semantic primitive: lowers to the `i2c.read_buffer` HAL op. The `buffer`
+ * argument is emitted as a placeholder (`__HAL_READ_BUF__`) that the var-init
+ * transformer rewrites to the caller's own buffer variable, so bytes land in
+ * the `uint8_t data[N]` declared in user scope — NOT an internal temp that
+ * decays to a pointer on return. Keeps `data.length` / `data[i]` valid.
+ */
+export declare function i2cReadBuffer(bus: string, count: number, buffer: number[] | Uint8Array): void;
 /** Initialize SPI bus. */
 export declare function spiBegin(bus: string): void;
 /** Disable SPI bus. */
@@ -67,6 +101,14 @@ export declare function spiEndTx(bus: string): void;
 export declare function spiCsLow(pin: number | string): void;
 /** Set SPI chip-select pin HIGH. */
 export declare function spiCsHigh(pin: number | string): void;
+/**
+ * Read `count` bytes from the SPI bus into a caller-provided buffer by clocking
+ * dummy (0x00) transfers. Semantic primitive: lowers to the `spi.read_buffer`
+ * HAL op (per-byte `bus.transfer(0)` read loop). The `buffer` placeholder is
+ * rewritten to the caller's variable. Mirrors i2cReadBuffer. The caller is
+ * responsible for asserting/de-asserting chip-select around it.
+ */
+export declare function spiReadBuffer(bus: string, count: number, buffer: number[] | Uint8Array): void;
 /** Set SPI data mode. */
 export declare function spiSetMode(bus: string, mode: number): void;
 /** Set SPI bit order. */
@@ -117,5 +159,102 @@ export declare function powerDeepSleep(ms: number): void;
 export declare function powerLightSleep(): void;
 /** Set the CPU frequency (MHz). */
 export declare function powerSetCpuFrequency(mhz: number): void;
+/** Enter deep sleep until `pin` reaches `level` (pin wakeup). Architecture-aware:
+ *  ext0 on Xtensa (RTC pins), gpio-wakeup on RISC-V. */
+export declare function powerDeepSleepPin(pin: number, level: number): void;
+export declare function preferencesBegin(namespace: string, readOnly: boolean): void;
+export declare function preferencesEnd(): void;
+export declare function preferencesClear(): void;
+export declare function preferencesRemove(key: string): void;
+export declare function preferencesPutInt(key: string, value: number): void;
+export declare function preferencesGetInt(key: string, defaultValue: number): number;
+export declare function preferencesPutUInt(key: string, value: number): void;
+export declare function preferencesGetUInt(key: string, defaultValue: number): number;
+export declare function preferencesPutBool(key: string, value: boolean): void;
+export declare function preferencesGetBool(key: string, defaultValue: boolean): boolean;
+export declare function preferencesPutFloat(key: string, value: number): void;
+export declare function preferencesGetFloat(key: string, defaultValue: number): number;
+export declare function preferencesPutString(key: string, value: string): void;
+export declare function preferencesGetString(key: string, defaultValue: string): string;
+export declare function wifiConnect(ssid: string, password?: string, timeoutMs?: number): boolean;
+export declare function wifiConnectStart(ssid: string, password?: string): void;
+export declare function wifiDisconnect(): void;
+export declare function wifiStatus(): number;
+export declare function wifiIsConnected(): boolean;
+export declare function wifiLocalIp(): string;
+export declare function wifiRssi(): number;
+export declare function wifiMac(): string;
+export declare function wifiSetHostname(name: string): void;
+export declare function wifiSetStaticIp(ip: string, gateway: string, subnet: string, dns?: string): void;
+export declare function wifiSetAutoReconnect(enabled: boolean): void;
+export declare function wifiSetPowerSave(mode: string): void;
+export declare function wifiSetTxPower(dbm: number): void;
+export declare function wifiOnEvent(event: string, handler: string): void;
+export declare function wifiApStart(ssid: string, password?: string, channel?: number, hidden?: boolean, maxClients?: number): boolean;
+export declare function wifiApStop(): void;
+export declare function wifiApClientCount(): number;
+export declare function wifiApIp(): string;
+export declare function wifiApSetChannel(channel: number): void;
+export declare function wifiApSetHidden(hidden: boolean): void;
+export declare function wifiApSetMaxClients(maxClients: number): void;
+export declare function wifiScan(): number;
+export declare function wifiScanStart(): void;
+export declare function wifiScanCount(): number;
+export declare function wifiScanSsid(index: number): string;
+export declare function wifiScanRssi(index: number): number;
+export declare function wifiScanEncryption(index: number): number;
+export declare function wifiScanChannel(index: number): number;
+export declare function wifiSaveCredentials(ssid: string, password: string): void;
+export declare function wifiConnectSaved(timeoutMs?: number): boolean;
+export declare function wifiClearCredentials(): void;
+export declare function wifiWaitConnected(timeoutMs?: number): boolean;
+export declare function wifiWaitDisconnected(): void;
+export declare function httpBegin(method: string, url: string): void;
+export declare function httpReset(): void;
+export declare function httpSetHeader(name: string, value: string): void;
+export declare function httpSetTimeout(ms: number): void;
+export declare function httpSetMaxBody(bytes: number): void;
+export declare function httpSetBody(data: string, json?: boolean): void;
+export declare function httpSetInsecure(): void;
+export declare function httpSetCaCert(pem: string): void;
+export declare function httpSend(): boolean;
+export declare function httpSendStart(): void;
+export declare function httpStatus(): number;
+export declare function httpOk(): boolean;
+export declare function httpBody(): string;
+export declare function httpContentLength(): number;
+export declare function httpResponseHeader(name: string): string;
+export declare function bleServerBegin(name: string): void;
+export declare function bleAdvertiseStart(): void;
+export declare function bleAdvertiseStop(): void;
+export declare function bleAddService(uuid: string): void;
+export declare function bleAddChar(index: number, uuid: string, type: string, perms: number, svcIndex: number): void;
+export declare function bleOnRead(index: number, handler: string): void;
+export declare function bleOnWrite(index: number, handler: string): void;
+export declare function bleOnConnect(handler: string): void;
+export declare function bleOnDisconnect(handler: string): void;
+export declare function bleNotify(index: number, value: number | string): void;
+export declare function bleIsConnected(): boolean;
+export declare function bleClientCount(): number;
+export declare function bleSetName(name: string): void;
+export declare function bleUntilConnected(timeoutMs?: number): boolean;
+export declare function bleUntilConnectedStart(): void;
+export declare function bleSetTxPower(dbm: number): void;
+export declare function bleStatus(): number;
 /** Emit raw C++ code (escape hatch for unsupported operations). */
 export declare function rawCpp(code: string): void;
+/**
+ * Emit raw C++ in expression context. Use when an IDF macro or constructor
+ * must produce a value (e.g. `WIFI_INIT_CONFIG_DEFAULT()` expands to a struct
+ * initializer; there's no TS-side way to construct it). The type parameter
+ * is purely a TS hint — the transpiler doesn't check it; it just emits the
+ * raw text in expression position.
+ *
+ *   const cfg = rawCpp<wifi_init_config_t>('WIFI_INIT_CONFIG_DEFAULT()');
+ *
+ * lowers to:
+ *
+ *   wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+ */
+export declare function rawCppExpr<T>(code: string): T;
+export {};