tasmota-webserial-esptool 6.0.1

package/dist/const.d.ts

@@ -0,0 +1,159 @@
+export interface Logger {
+    log(msg: string, ...args: any[]): void;
+    error(msg: string, ...args: any[]): void;
+    debug(msg: string, ...args: any[]): void;
+}
+export declare const baudRates: number[];
+export declare const FLASH_SIZES: {
+    "512KB": number;
+    "256KB": number;
+    "1MB": number;
+    "2MB": number;
+    "4MB": number;
+    "2MB-c1": number;
+    "4MB-c1": number;
+    "8MB": number;
+    "16MB": number;
+};
+export declare const ESP32_FLASH_SIZES: {
+    "1MB": number;
+    "2MB": number;
+    "4MB": number;
+    "8MB": number;
+    "16MB": number;
+    "32MB": number;
+    "64MB": number;
+    "128MB": number;
+};
+interface FlashSize {
+    [key: number]: string;
+}
+export declare const DETECTED_FLASH_SIZES: FlashSize;
+export declare const FLASH_WRITE_SIZE = 1024;
+export declare const STUB_FLASH_WRITE_SIZE = 16384;
+export declare const FLASH_SECTOR_SIZE = 4096;
+export declare const ESP_ROM_BAUD = 115200;
+export declare const USB_JTAG_SERIAL_PID = 4097;
+export declare const ESP8266_SPI_REG_BASE = 1610613248;
+export declare const ESP8266_BASEFUSEADDR = 1072693328;
+export declare const ESP8266_MACFUSEADDR = 1072693328;
+export declare const ESP8266_SPI_USR_OFFS = 28;
+export declare const ESP8266_SPI_USR1_OFFS = 32;
+export declare const ESP8266_SPI_USR2_OFFS = 36;
+export declare const ESP8266_SPI_MOSI_DLEN_OFFS = -1;
+export declare const ESP8266_SPI_MISO_DLEN_OFFS = -1;
+export declare const ESP8266_SPI_W0_OFFS = 64;
+export declare const ESP8266_UART_DATE_REG_ADDR = 1610612856;
+export declare const ESP8266_BOOTLOADER_FLASH_OFFSET = 0;
+export declare const ESP32_SPI_REG_BASE = 1072963584;
+export declare const ESP32_BASEFUSEADDR = 1073061888;
+export declare const ESP32_MACFUSEADDR = 1073061888;
+export declare const ESP32_SPI_USR_OFFS = 28;
+export declare const ESP32_SPI_USR1_OFFS = 32;
+export declare const ESP32_SPI_USR2_OFFS = 36;
+export declare const ESP32_SPI_MOSI_DLEN_OFFS = 40;
+export declare const ESP32_SPI_MISO_DLEN_OFFS = 44;
+export declare const ESP32_SPI_W0_OFFS = 128;
+export declare const ESP32_UART_DATE_REG_ADDR = 1610612856;
+export declare const ESP32_BOOTLOADER_FLASH_OFFSET = 4096;
+export declare const ESP32S2_SPI_REG_BASE = 1061167104;
+export declare const ESP32S2_BASEFUSEADDR = 1061265408;
+export declare const ESP32S2_MACFUSEADDR = 1061265476;
+export declare const ESP32S2_SPI_USR_OFFS = 24;
+export declare const ESP32S2_SPI_USR1_OFFS = 28;
+export declare const ESP32S2_SPI_USR2_OFFS = 32;
+export declare const ESP32S2_SPI_MOSI_DLEN_OFFS = 36;
+export declare const ESP32S2_SPI_MISO_DLEN_OFFS = 40;
+export declare const ESP32S2_SPI_W0_OFFS = 88;
+export declare const ESP32S2_UART_DATE_REG_ADDR = 1610612856;
+export declare const ESP32S2_BOOTLOADER_FLASH_OFFSET = 4096;
+export declare const ESP32S3_SPI_REG_BASE = 1610620928;
+export declare const ESP32S3_BASEFUSEADDR = 1610641408;
+export declare const ESP32S3_MACFUSEADDR: number;
+export declare const ESP32S3_SPI_USR_OFFS = 24;
+export declare const ESP32S3_SPI_USR1_OFFS = 28;
+export declare const ESP32S3_SPI_USR2_OFFS = 32;
+export declare const ESP32S3_SPI_MOSI_DLEN_OFFS = 36;
+export declare const ESP32S3_SPI_MISO_DLEN_OFFS = 40;
+export declare const ESP32S3_SPI_W0_OFFS = 88;
+export declare const ESP32S3_UART_DATE_REG_ADDR = 1610612864;
+export declare const ESP32S3_BOOTLOADER_FLASH_OFFSET = 0;
+export declare const ESP32C3_SPI_REG_BASE = 1610620928;
+export declare const ESP32C3_BASEFUSEADDR = 1610647552;
+export declare const ESP32C3_MACFUSEADDR: number;
+export declare const ESP32C3_SPI_USR_OFFS = 24;
+export declare const ESP32C3_SPI_USR1_OFFS = 28;
+export declare const ESP32C3_SPI_USR2_OFFS = 32;
+export declare const ESP32C3_SPI_MOSI_DLEN_OFFS = 36;
+export declare const ESP32C3_SPI_MISO_DLEN_OFFS = 40;
+export declare const ESP32C3_SPI_W0_OFFS = 88;
+export declare const ESP32C3_UART_DATE_REG_ADDR = 1610612860;
+export declare const ESP32C3_BOOTLOADER_FLASH_OFFSET = 0;
+export interface SpiFlashAddresses {
+    regBase: number;
+    baseFuse: number;
+    macFuse: number;
+    usrOffs: number;
+    usr1Offs: number;
+    usr2Offs: number;
+    mosiDlenOffs: number;
+    misoDlenOffs: number;
+    w0Offs: number;
+    uartDateReg: number;
+    flashOffs: number;
+}
+export declare const SYNC_PACKET: number[];
+export declare const CHIP_DETECT_MAGIC_REG_ADDR = 1073745920;
+export declare const CHIP_FAMILY_ESP8266 = 33382;
+export declare const CHIP_FAMILY_ESP32 = 50;
+export declare const CHIP_FAMILY_ESP32S2 = 12882;
+export declare const CHIP_FAMILY_ESP32S3 = 12883;
+export declare const CHIP_FAMILY_ESP32C3 = 12995;
+export declare const CHIP_FAMILY_ESP32C6 = 12998;
+export declare const CHIP_FAMILY_ESP32H2 = 12914;
+export type ChipFamily = typeof CHIP_FAMILY_ESP8266 | typeof CHIP_FAMILY_ESP32 | typeof CHIP_FAMILY_ESP32S2 | typeof CHIP_FAMILY_ESP32S3 | typeof CHIP_FAMILY_ESP32C3 | typeof CHIP_FAMILY_ESP32C6 | typeof CHIP_FAMILY_ESP32H2;
+interface ChipInfo {
+    [magicValue: number]: {
+        name: string;
+        family: ChipFamily;
+    };
+}
+export declare const CHIP_DETECT_MAGIC_VALUES: ChipInfo;
+export declare const ESP_FLASH_BEGIN = 2;
+export declare const ESP_FLASH_DATA = 3;
+export declare const ESP_FLASH_END = 4;
+export declare const ESP_MEM_BEGIN = 5;
+export declare const ESP_MEM_END = 6;
+export declare const ESP_MEM_DATA = 7;
+export declare const ESP_SYNC = 8;
+export declare const ESP_WRITE_REG = 9;
+export declare const ESP_READ_REG = 10;
+export declare const ESP_ERASE_FLASH = 208;
+export declare const ESP_ERASE_REGION = 209;
+export declare const ESP_SPI_SET_PARAMS = 11;
+export declare const ESP_SPI_ATTACH = 13;
+export declare const ESP_CHANGE_BAUDRATE = 15;
+export declare const ESP_SPI_FLASH_MD5 = 19;
+export declare const ESP_CHECKSUM_MAGIC = 239;
+export declare const ESP_FLASH_DEFL_BEGIN = 16;
+export declare const ESP_FLASH_DEFL_DATA = 17;
+export declare const ESP_FLASH_DEFL_END = 18;
+export declare const ROM_INVALID_RECV_MSG = 5;
+export declare const USB_RAM_BLOCK = 2048;
+export declare const ESP_RAM_BLOCK = 6144;
+export declare const DEFAULT_TIMEOUT = 3000;
+export declare const CHIP_ERASE_TIMEOUT = 600000;
+export declare const MAX_TIMEOUT: number;
+export declare const SYNC_TIMEOUT = 100;
+export declare const ERASE_REGION_TIMEOUT_PER_MB = 30000;
+export declare const MEM_END_ROM_TIMEOUT = 500;
+/**
+ * @name timeoutPerMb
+ * Scales timeouts which are size-specific
+ */
+export declare const timeoutPerMb: (secondsPerMb: number, sizeBytes: number) => number;
+export declare const getSpiFlashAddresses: (chipFamily: ChipFamily) => SpiFlashAddresses;
+export declare class SlipReadError extends Error {
+    constructor(message: string);
+}
+export {};

package/dist/const.js

@@ -0,0 +1,252 @@
+import { toByteArray } from "./util";
+export const baudRates = [
+    115200, 128000, 153600, 230400, 460800, 921600, 1500000, 2000000,
+];
+export const FLASH_SIZES = {
+    "512KB": 0x00,
+    "256KB": 0x10,
+    "1MB": 0x20,
+    "2MB": 0x30,
+    "4MB": 0x40,
+    "2MB-c1": 0x50,
+    "4MB-c1": 0x60,
+    "8MB": 0x80,
+    "16MB": 0x90,
+};
+export const ESP32_FLASH_SIZES = {
+    "1MB": 0x00,
+    "2MB": 0x10,
+    "4MB": 0x20,
+    "8MB": 0x30,
+    "16MB": 0x40,
+    "32MB": 0x50,
+    "64MB": 0x60,
+    "128MB": 0x70,
+};
+export const DETECTED_FLASH_SIZES = {
+    0x12: "256KB",
+    0x13: "512KB",
+    0x14: "1MB",
+    0x15: "2MB",
+    0x16: "4MB",
+    0x17: "8MB",
+    0x18: "16MB",
+    0x19: "32MB",
+    0x1a: "64MB",
+};
+export const FLASH_WRITE_SIZE = 0x400;
+export const STUB_FLASH_WRITE_SIZE = 0x4000;
+export const FLASH_SECTOR_SIZE = 0x1000; // Flash sector size, minimum unit of erase.
+export const ESP_ROM_BAUD = 115200;
+export const USB_JTAG_SERIAL_PID = 0x1001;
+export const ESP8266_SPI_REG_BASE = 0x60000200;
+export const ESP8266_BASEFUSEADDR = 0x3ff00050;
+export const ESP8266_MACFUSEADDR = 0x3ff00050;
+export const ESP8266_SPI_USR_OFFS = 0x1c;
+export const ESP8266_SPI_USR1_OFFS = 0x20;
+export const ESP8266_SPI_USR2_OFFS = 0x24;
+export const ESP8266_SPI_MOSI_DLEN_OFFS = -1;
+export const ESP8266_SPI_MISO_DLEN_OFFS = -1;
+export const ESP8266_SPI_W0_OFFS = 0x40;
+export const ESP8266_UART_DATE_REG_ADDR = 0x60000078;
+export const ESP8266_BOOTLOADER_FLASH_OFFSET = 0x0;
+export const ESP32_SPI_REG_BASE = 0x3ff42000;
+export const ESP32_BASEFUSEADDR = 0x3ff5a000;
+export const ESP32_MACFUSEADDR = 0x3ff5a000;
+export const ESP32_SPI_USR_OFFS = 0x1c;
+export const ESP32_SPI_USR1_OFFS = 0x20;
+export const ESP32_SPI_USR2_OFFS = 0x24;
+export const ESP32_SPI_MOSI_DLEN_OFFS = 0x28;
+export const ESP32_SPI_MISO_DLEN_OFFS = 0x2c;
+export const ESP32_SPI_W0_OFFS = 0x80;
+export const ESP32_UART_DATE_REG_ADDR = 0x60000078;
+export const ESP32_BOOTLOADER_FLASH_OFFSET = 0x1000;
+export const ESP32S2_SPI_REG_BASE = 0x3f402000;
+export const ESP32S2_BASEFUSEADDR = 0x3f41a000;
+export const ESP32S2_MACFUSEADDR = 0x3f41a044;
+export const ESP32S2_SPI_USR_OFFS = 0x18;
+export const ESP32S2_SPI_USR1_OFFS = 0x1c;
+export const ESP32S2_SPI_USR2_OFFS = 0x20;
+export const ESP32S2_SPI_MOSI_DLEN_OFFS = 0x24;
+export const ESP32S2_SPI_MISO_DLEN_OFFS = 0x28;
+export const ESP32S2_SPI_W0_OFFS = 0x58;
+export const ESP32S2_UART_DATE_REG_ADDR = 0x60000078;
+export const ESP32S2_BOOTLOADER_FLASH_OFFSET = 0x1000;
+export const ESP32S3_SPI_REG_BASE = 0x60002000;
+export const ESP32S3_BASEFUSEADDR = 0x60007000;
+export const ESP32S3_MACFUSEADDR = 0x60007000 + 0x044;
+export const ESP32S3_SPI_USR_OFFS = 0x18;
+export const ESP32S3_SPI_USR1_OFFS = 0x1c;
+export const ESP32S3_SPI_USR2_OFFS = 0x20;
+export const ESP32S3_SPI_MOSI_DLEN_OFFS = 0x24;
+export const ESP32S3_SPI_MISO_DLEN_OFFS = 0x28;
+export const ESP32S3_SPI_W0_OFFS = 0x58;
+export const ESP32S3_UART_DATE_REG_ADDR = 0x60000080;
+export const ESP32S3_BOOTLOADER_FLASH_OFFSET = 0x0;
+export const ESP32C3_SPI_REG_BASE = 0x60002000;
+export const ESP32C3_BASEFUSEADDR = 0x60008800;
+export const ESP32C3_MACFUSEADDR = 0x60008800 + 0x044;
+export const ESP32C3_SPI_USR_OFFS = 0x18;
+export const ESP32C3_SPI_USR1_OFFS = 0x1c;
+export const ESP32C3_SPI_USR2_OFFS = 0x20;
+export const ESP32C3_SPI_MOSI_DLEN_OFFS = 0x24;
+export const ESP32C3_SPI_MISO_DLEN_OFFS = 0x28;
+export const ESP32C3_SPI_W0_OFFS = 0x58;
+export const ESP32C3_UART_DATE_REG_ADDR = 0x6000007c;
+export const ESP32C3_BOOTLOADER_FLASH_OFFSET = 0x0;
+export const SYNC_PACKET = toByteArray("\x07\x07\x12 UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU");
+export const CHIP_DETECT_MAGIC_REG_ADDR = 0x40001000;
+// These values for the families are made up; nothing that esptool uses.
+export const CHIP_FAMILY_ESP8266 = 0x8266;
+export const CHIP_FAMILY_ESP32 = 0x32;
+export const CHIP_FAMILY_ESP32S2 = 0x3252;
+export const CHIP_FAMILY_ESP32S3 = 0x3253;
+export const CHIP_FAMILY_ESP32C3 = 0x32c3;
+export const CHIP_FAMILY_ESP32C6 = 0x32c6;
+export const CHIP_FAMILY_ESP32H2 = 0x3272;
+export const CHIP_DETECT_MAGIC_VALUES = {
+    0xfff0c101: { name: "ESP8266", family: CHIP_FAMILY_ESP8266 },
+    0x00f01d83: { name: "ESP32", family: CHIP_FAMILY_ESP32 },
+    0x000007c6: { name: "ESP32-S2", family: CHIP_FAMILY_ESP32S2 },
+    0x9: { name: "ESP32-S3", family: CHIP_FAMILY_ESP32S3 },
+    0xeb004136: { name: "ESP32-S3(beta2)", family: CHIP_FAMILY_ESP32S3 },
+    0x6921506f: { name: "ESP32-C3", family: CHIP_FAMILY_ESP32C3 },
+    0x1b31506f: { name: "ESP32-C3", family: CHIP_FAMILY_ESP32C3 },
+    0xca26cc22: { name: "ESP32-H2", family: CHIP_FAMILY_ESP32H2 },
+    0x0da1806f: { name: "ESP32-C6(beta)", family: CHIP_FAMILY_ESP32C6 },
+};
+// Commands supported by ESP8266 ROM bootloader
+export const ESP_FLASH_BEGIN = 0x02;
+export const ESP_FLASH_DATA = 0x03;
+export const ESP_FLASH_END = 0x04;
+export const ESP_MEM_BEGIN = 0x05;
+export const ESP_MEM_END = 0x06;
+export const ESP_MEM_DATA = 0x07;
+export const ESP_SYNC = 0x08;
+export const ESP_WRITE_REG = 0x09;
+export const ESP_READ_REG = 0x0a;
+export const ESP_ERASE_FLASH = 0xd0;
+export const ESP_ERASE_REGION = 0xd1;
+export const ESP_SPI_SET_PARAMS = 0x0b;
+export const ESP_SPI_ATTACH = 0x0d;
+export const ESP_CHANGE_BAUDRATE = 0x0f;
+export const ESP_SPI_FLASH_MD5 = 0x13;
+export const ESP_CHECKSUM_MAGIC = 0xef;
+export const ESP_FLASH_DEFL_BEGIN = 0x10;
+export const ESP_FLASH_DEFL_DATA = 0x11;
+export const ESP_FLASH_DEFL_END = 0x12;
+export const ROM_INVALID_RECV_MSG = 0x05;
+export const USB_RAM_BLOCK = 0x800;
+export const ESP_RAM_BLOCK = 0x1800;
+// Timeouts
+export const DEFAULT_TIMEOUT = 3000;
+export const CHIP_ERASE_TIMEOUT = 600000; // timeout for full chip erase in ms
+export const MAX_TIMEOUT = CHIP_ERASE_TIMEOUT * 2; // longest any command can run in ms
+export const SYNC_TIMEOUT = 100; // timeout for syncing with bootloader in ms
+export const ERASE_REGION_TIMEOUT_PER_MB = 30000; // timeout (per megabyte) for erasing a region in ms
+export const MEM_END_ROM_TIMEOUT = 500;
+/**
+ * @name timeoutPerMb
+ * Scales timeouts which are size-specific
+ */
+export const timeoutPerMb = (secondsPerMb, sizeBytes) => {
+    let result = Math.floor(secondsPerMb * (sizeBytes / 0x1e6));
+    if (result < DEFAULT_TIMEOUT) {
+        return DEFAULT_TIMEOUT;
+    }
+    return result;
+};
+export const getSpiFlashAddresses = (chipFamily) => {
+    switch (chipFamily) {
+        case CHIP_FAMILY_ESP32:
+            return {
+                regBase: ESP32_SPI_REG_BASE,
+                baseFuse: ESP32_BASEFUSEADDR,
+                macFuse: ESP32_MACFUSEADDR,
+                usrOffs: ESP32_SPI_USR_OFFS,
+                usr1Offs: ESP32_SPI_USR1_OFFS,
+                usr2Offs: ESP32_SPI_USR2_OFFS,
+                mosiDlenOffs: ESP32_SPI_MOSI_DLEN_OFFS,
+                misoDlenOffs: ESP32_SPI_MISO_DLEN_OFFS,
+                w0Offs: ESP32_SPI_W0_OFFS,
+                uartDateReg: ESP32_UART_DATE_REG_ADDR,
+                flashOffs: ESP32_BOOTLOADER_FLASH_OFFSET,
+            };
+        case CHIP_FAMILY_ESP32S2:
+            return {
+                regBase: ESP32S2_SPI_REG_BASE,
+                baseFuse: ESP32S2_BASEFUSEADDR,
+                macFuse: ESP32S2_MACFUSEADDR,
+                usrOffs: ESP32S2_SPI_USR_OFFS,
+                usr1Offs: ESP32S2_SPI_USR1_OFFS,
+                usr2Offs: ESP32S2_SPI_USR2_OFFS,
+                mosiDlenOffs: ESP32S2_SPI_MOSI_DLEN_OFFS,
+                misoDlenOffs: ESP32S2_SPI_MISO_DLEN_OFFS,
+                w0Offs: ESP32S2_SPI_W0_OFFS,
+                uartDateReg: ESP32S2_UART_DATE_REG_ADDR,
+                flashOffs: ESP32S2_BOOTLOADER_FLASH_OFFSET,
+            };
+        case CHIP_FAMILY_ESP32S3:
+            return {
+                regBase: ESP32S3_SPI_REG_BASE,
+                usrOffs: ESP32S3_SPI_USR_OFFS,
+                baseFuse: ESP32S3_BASEFUSEADDR,
+                macFuse: ESP32S3_MACFUSEADDR,
+                usr1Offs: ESP32S3_SPI_USR1_OFFS,
+                usr2Offs: ESP32S3_SPI_USR2_OFFS,
+                mosiDlenOffs: ESP32S3_SPI_MOSI_DLEN_OFFS,
+                misoDlenOffs: ESP32S3_SPI_MISO_DLEN_OFFS,
+                w0Offs: ESP32S3_SPI_W0_OFFS,
+                uartDateReg: ESP32S3_UART_DATE_REG_ADDR,
+                flashOffs: ESP32S3_BOOTLOADER_FLASH_OFFSET,
+            };
+        case CHIP_FAMILY_ESP8266:
+            return {
+                regBase: ESP8266_SPI_REG_BASE,
+                usrOffs: ESP8266_SPI_USR_OFFS,
+                baseFuse: ESP8266_BASEFUSEADDR,
+                macFuse: ESP8266_MACFUSEADDR,
+                usr1Offs: ESP8266_SPI_USR1_OFFS,
+                usr2Offs: ESP8266_SPI_USR2_OFFS,
+                mosiDlenOffs: ESP8266_SPI_MOSI_DLEN_OFFS,
+                misoDlenOffs: ESP8266_SPI_MISO_DLEN_OFFS,
+                w0Offs: ESP8266_SPI_W0_OFFS,
+                uartDateReg: ESP8266_UART_DATE_REG_ADDR,
+                flashOffs: ESP8266_BOOTLOADER_FLASH_OFFSET,
+            };
+        case CHIP_FAMILY_ESP32C3:
+            return {
+                regBase: ESP32C3_SPI_REG_BASE,
+                baseFuse: ESP32C3_BASEFUSEADDR,
+                macFuse: ESP32C3_MACFUSEADDR,
+                usrOffs: ESP32C3_SPI_USR_OFFS,
+                usr1Offs: ESP32C3_SPI_USR1_OFFS,
+                usr2Offs: ESP32C3_SPI_USR2_OFFS,
+                mosiDlenOffs: ESP32C3_SPI_MOSI_DLEN_OFFS,
+                misoDlenOffs: ESP32C3_SPI_MISO_DLEN_OFFS,
+                w0Offs: ESP32C3_SPI_W0_OFFS,
+                uartDateReg: ESP32C3_UART_DATE_REG_ADDR,
+                flashOffs: ESP32C3_BOOTLOADER_FLASH_OFFSET,
+            };
+        default:
+            return {
+                regBase: -1,
+                baseFuse: -1,
+                macFuse: -1,
+                usrOffs: -1,
+                usr1Offs: -1,
+                usr2Offs: -1,
+                mosiDlenOffs: -1,
+                misoDlenOffs: -1,
+                w0Offs: -1,
+                uartDateReg: -1,
+                flashOffs: -1,
+            };
+    }
+};
+export class SlipReadError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SlipReadError";
+    }
+}

package/dist/esp_loader.d.ts

@@ -0,0 +1,166 @@
+/// <reference types="w3c-web-serial" />
+import { Logger, ChipFamily, SpiFlashAddresses } from "./const";
+export declare class ESPLoader extends EventTarget {
+    port: SerialPort;
+    logger: Logger;
+    private _parent?;
+    chipFamily: ChipFamily;
+    chipName: string | null;
+    _efuses: any[];
+    _flashsize: number;
+    debug: boolean;
+    IS_STUB: boolean;
+    connected: boolean;
+    flashSize: string | null;
+    __inputBuffer?: number[];
+    private _reader?;
+    constructor(port: SerialPort, logger: Logger, _parent?: ESPLoader | undefined);
+    private get _inputBuffer();
+    initialize(): Promise<void>;
+    /**
+     * @name readLoop
+     * Reads data from the input stream and places it in the inputBuffer
+     */
+    readLoop(): Promise<void>;
+    sleep(ms?: number): Promise<unknown>;
+    state_DTR: boolean;
+    setRTS(state: boolean): Promise<void>;
+    setDTR(state: boolean): Promise<void>;
+    hardReset(bootloader?: boolean): Promise<void>;
+    /**
+     * @name macAddr
+     * The MAC address burned into the OTP memory of the ESP chip
+     */
+    macAddr(): any[];
+    readRegister(reg: number): Promise<number>;
+    /**
+     * @name checkCommand
+     * Send a command packet, check that the command succeeded and
+     * return a tuple with the value and data.
+     * See the ESP Serial Protocol for more details on what value/data are
+     */
+    checkCommand(opcode: number, buffer: number[], checksum?: number, timeout?: number): Promise<[number, number[]]>;
+    /**
+     * @name sendCommand
+     * Send a slip-encoded, checksummed command over the UART,
+     * does not check response
+     */
+    sendCommand(opcode: number, buffer: number[], checksum?: number): Promise<void>;
+    /**
+     * @name readPacket
+     * Generator to read SLIP packets from a serial port.
+     * Yields one full SLIP packet at a time, raises exception on timeout or invalid data.
+     * Designed to avoid too many calls to serial.read(1), which can bog
+     * down on slow systems.
+     */
+    readPacket(timeout: number): Promise<number[]>;
+    /**
+     * @name getResponse
+     * Read response data and decodes the slip packet, then parses
+     * out the value/data and returns as a tuple of (value, data) where
+     * each is a list of bytes
+     */
+    getResponse(opcode: number, timeout?: number): Promise<[number, number[]]>;
+    /**
+     * @name checksum
+     * Calculate checksum of a blob, as it is defined by the ROM
+     */
+    checksum(data: number[], state?: number): number;
+    setBaudrate(baud: number): Promise<void>;
+    reconfigurePort(baud: number): Promise<void>;
+    /**
+     * @name sync
+     * Put into ROM bootload mode & attempt to synchronize with the
+     * ESP ROM bootloader, we will retry a few times
+     */
+    sync(): Promise<boolean>;
+    /**
+     * @name _sync
+     * Perform a soft-sync using AT sync packets, does not perform
+     * any hardware resetting
+     */
+    _sync(): Promise<boolean>;
+    /**
+     * @name getFlashWriteSize
+     * Get the Flash write size based on the chip
+     */
+    getFlashWriteSize(): 1024 | 16384;
+    /**
+     * @name flashData
+     * Program a full, uncompressed binary file into SPI Flash at
+     *   a given offset. If an ESP32 and md5 string is passed in, will also
+     *   verify memory. ESP8266 does not have checksum memory verification in
+     *   ROM
+     */
+    flashData(binaryData: ArrayBuffer, updateProgress: (bytesWritten: number, totalBytes: number) => void, offset?: number, compress?: boolean): Promise<void>;
+    /**
+     * @name flashBlock
+     * Send one block of data to program into SPI Flash memory
+     */
+    flashBlock(data: number[], seq: number, timeout?: number): Promise<void>;
+    flashDeflBlock(data: number[], seq: number, timeout?: number): Promise<void>;
+    /**
+     * @name flashBegin
+     * Prepare for flashing by attaching SPI chip and erasing the
+     *   number of blocks requred.
+     */
+    flashBegin(size?: number, offset?: number, encrypted?: boolean): Promise<number>;
+    /**
+     * @name flashDeflBegin
+     *
+     */
+    flashDeflBegin(size?: number, compressedSize?: number, offset?: number, encrypted?: boolean): Promise<number>;
+    flashFinish(): Promise<void>;
+    flashDeflFinish(): Promise<void>;
+    getBootloaderOffset(): number;
+    flashId(): Promise<number>;
+    getChipFamily(): ChipFamily;
+    writeRegister(address: number, value: number, mask?: number, delayUs?: number, delayAfterUs?: number): Promise<void>;
+    setDataLengths(spiAddresses: SpiFlashAddresses, mosiBits: number, misoBits: number): Promise<void>;
+    waitDone(spiCmdReg: number, spiCmdUsr: number): Promise<void>;
+    runSpiFlashCommand(spiflashCommand: number, data: number[], readBits?: number): Promise<number>;
+    detectFlashSize(): Promise<void>;
+    /**
+     * @name getEraseSize
+     * Calculate an erase size given a specific size in bytes.
+     *   Provides a workaround for the bootloader erase bug on ESP8266.
+     */
+    getEraseSize(offset: number, size: number): number;
+    /**
+     * @name memBegin (592)
+     * Start downloading an application image to RAM
+     */
+    memBegin(size: number, blocks: number, blocksize: number, offset: number): Promise<[number, number[]]>;
+    /**
+     * @name memBlock (609)
+     * Send a block of an image to RAM
+     */
+    memBlock(data: number[], seq: number): Promise<[number, number[]]>;
+    /**
+     * @name memFinish (615)
+     * Leave download mode and run the application
+     *
+     * Sending ESP_MEM_END usually sends a correct response back, however sometimes
+     * (with ROM loader) the executed code may reset the UART or change the baud rate
+     * before the transmit FIFO is empty. So in these cases we set a short timeout and
+     * ignore errors.
+     */
+    memFinish(entrypoint?: number): Promise<[number, number[]]>;
+    runStub(): Promise<EspStubLoader>;
+    writeToStream(data: number[]): Promise<void>;
+    disconnect(): Promise<void>;
+}
+declare class EspStubLoader extends ESPLoader {
+    IS_STUB: boolean;
+    /**
+     * @name memBegin (592)
+     * Start downloading an application image to RAM
+     */
+    memBegin(size: number, blocks: number, blocksize: number, offset: number): Promise<any>;
+    /**
+     * @name getEraseSize
+     * depending on flash chip model the erase may take this long (maybe longer!)
+     */
+    eraseFlash(): Promise<void>;
+}
+export {};