@moddable/typings 6.1.0 → 7.0.0

package/display.d.ts

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2025  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ *
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+declare module "embedded:display" {
+	export interface DisplayConstructorOptions {
+		format?: number;
+		rotation?: number;
+		brightness?: number;
+		flip?: "h" | "v" | "hv";
+	}
+
+	export interface DisplayConfigureOptions {
+		brightness?: number;
+		format?: number;
+		rotation?: number;
+	}
+
+	export interface DisplayConfiguration {
+		brightness?: number;
+		format?: number;
+		rotation?: number;
+	}
+
+	export interface DisplayBeginOptions {
+		x: number;
+		y: number;
+		width: number;
+		height: number;
+		continue?: boolean;
+	}
+
+	export interface DisplayRectangle {
+		x: number;
+		y: number;
+		width: number;
+		height: number;
+	}
+
+	export default class Display {
+		constructor(options: DisplayConstructorOptions);
+		close(): void;
+		configure(options: DisplayConfigureOptions): void;
+		get configuration(): DisplayConfiguration;
+		begin(options?: DisplayBeginOptions): void;
+		send(buffer: BufferLike): void;
+		end(): void;
+		adapInvalid(options: DisplayRectangle): void;
+		get width(): number;
+		get height(): number;
+	}
+}

package/dns/parser.d.ts

@@ -1,5 +1,6 @@
 /*
 * Copyright (c) 2019-2020 Bradley Farias
+* Copyright (c) 2026 Moddable Tech, Inc.
 *
 *   This file is part of the Moddable SDK Tools.
 *
@@ -19,19 +20,73 @@
 */
 
 declare module "dns/parser" {
+  interface DNSQuestion {
+      qname: string[];
+      qtype: number;
+      qclass: number;
+  }
+
+  interface DNSSRVData {
+      priority: number;
+      weight: number;
+      port: number;
+      target: string[];
+  }
+
+  interface DNSAnswerA {
+      qname: string[];
+      qtype: 0x0001;
+      qclass: number;
+      ttl: number;
+      rdata: string;
+  }
+
+  interface DNSAnswerPTR {
+      qname: string[];
+      qtype: 0x000C;
+      qclass: number;
+      ttl: number;
+      rdata: string[];
+  }
+
+  interface DNSAnswerTXT {
+      qname: string[];
+      qtype: 0x0010;
+      qclass: number;
+      ttl: number;
+      rdata: string[];
+  }
+
+  interface DNSAnswerSRV {
+      qname: string[];
+      qtype: 0x0021;
+      qclass: number;
+      ttl: number;
+      rdata: DNSSRVData;
+  }
+
+  interface DNSAnswerOther {
+      qname: string[];
+      qtype: number;
+      qclass: number;
+      ttl: number;
+      rdata: "UNHANDLED";
+  }
+
+  type DNSAnswer = DNSAnswerA | DNSAnswerPTR | DNSAnswerTXT | DNSAnswerSRV | DNSAnswerOther;
+    
   class Parser {
-    constructor(buffer: ArrayBuffer);
+    constructor(buffer: BufferLike);
     get id(): number;
     get flags(): number;
     get questions(): number;
     get answers(): number;
     get authorities(): number;
     get additionals(): number;
-    // TODO: not use unknown
-    question(index: number): unknown;
-    answer(index: number): unknown;
-    authority(index: number): unknown;
-    additional(index: number): unknown;
+    question(index: number): DNSQuestion;
+    answer(index: number): DNSAnswer;
+    authority(index: number): DNSAnswer;
+    additional(index: number): DNSAnswer;
   }
   export {Parser as default};
 }

package/dns/serializer.d.ts

@@ -25,14 +25,15 @@ declare module "dns/serializer" {
       opcode?: (typeof DNS.OPCODE)[keyof (typeof DNS.OPCODE)],
       query?: boolean,
       authoritative?: boolean,
-      id?: number
+      id?: number,
+      recursionDesired?: boolean,
     });
     add(
       section: (typeof DNS.SECTION)[keyof (typeof DNS.SECTION)],
       name: string,
       type: (typeof DNS.RR)[keyof (typeof DNS.RR)],
       classType: (typeof DNS.CLASS)[keyof (typeof DNS.CLASS)],
-      ttl: number,
+      ttl?: number,
       data?: ArrayBuffer
     ): void;
     build(): ArrayBuffer;

package/embedded/RTC.d.ts

@@ -0,0 +1,42 @@
+/*
+* Copyright (c) 2025 Moddable Tech, Inc.
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "embedded:RTC" {
+	import type {PortSpecifier} from "embedded:io/_common";
+
+	export interface RTCOptions {
+		target?: any;
+		port?: PortSpecifier;
+		onAlarm?: () => void;
+	}
+
+	export interface RTCConfigureOptions {
+		alarm?: number;
+	}
+
+	export class RTC {
+		constructor(options: RTCOptions);
+		close(): void;
+		time: number;
+		configure(options: RTCConfigureOptions): void;
+	}
+
+	export default RTC;
+}

package/embedded/display.d.ts

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2025  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ *
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+declare module "embedded:display" {
+	import type Bitmap from "commodetto/Bitmap";
+	import type { Rectangle } from "commodetto/Poco";
+
+	export interface DisplayConstructorOptions {
+		port: string;
+	}
+
+	export interface DisplayConfigureOptions {
+		brightness?: number; // 0-1 range
+		rotation?: 0 | 90 | 180 | 270;
+		format?: typeof Bitmap.RGB565LE | typeof Bitmap.RGB24 | typeof Bitmap.Gray256;
+	}
+
+	export interface DisplayConfiguration {
+		brightness: number; // 0-1 range
+		rotation: 0 | 90 | 180 | 270;
+		format: typeof Bitmap.RGB565LE | typeof Bitmap.RGB24 | typeof Bitmap.Gray256;
+	}
+
+	export interface DisplayBeginOptions {
+		x: number;
+		y: number;
+		width: number;
+		height: number;
+	}
+
+	class Display {
+		constructor(options: DisplayConstructorOptions);
+		close(): void;
+
+		configure(options: DisplayConfigureOptions): void;
+		get configuration(): DisplayConfiguration;
+
+		begin(options: DisplayBeginOptions): void;
+		begin(): void;
+		send(buffer: BufferLike): void;
+		send(buffer: BufferLike, offset: number, length: number): void;
+		end(): void;
+
+		adapInvalid(rectangle: Rectangle): void;
+
+		get width(): number;
+		get height(): number;
+	}
+
+	export default Display;
+}

package/embedded/storage/files.d.ts

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2024-2025  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ * 
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ * 
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ * 
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+declare module "embedded:storage/files" {
+	export class Status {
+		size: number;
+		mode: number;
+		isFile(): boolean;
+		isDirectory(): boolean;
+		isSymbolicLink(): boolean;
+	}
+
+	export class File {
+		// Use Directory.openFile() to create File instances
+		close(): void;
+
+		read(count: number, position: number): ArrayBuffer;
+		read(buffer: BufferLike, position: number): number;
+		write(buffer: BufferLike, position: number): void;
+
+		status(): Status;
+		setSize(length: number): void;
+		flush(): void;
+	}
+
+	export interface DirectoryOpenFileOptions {
+		path: string;
+		mode?: "r" | "r+" | "w" | "w+";
+	}
+
+	export interface DirectoryOpenDirectoryOptions {
+		path: string;
+	}
+
+	export interface DirectoryStatusOptions {
+		resolveTarget?: boolean;
+	}
+
+	export class Directory {
+		// use device.files to access file system root
+		close(): void;
+
+		openFile(options: DirectoryOpenFileOptions): File;
+		openDirectory(options: DirectoryOpenDirectoryOptions): Directory;
+
+		delete(path: string): boolean;
+		move(from: string, to: string, toDirectory?: Directory): void;
+
+		status(path: string, options?: DirectoryStatusOptions): Status;
+
+		createDirectory(path: string): boolean;
+		createLink(path: string, target: string): void;
+		readLink(path: string): string;
+
+		scan(path?: string): IterableIterator<string>;
+		[Symbol.iterator](): IterableIterator<string>;
+	}
+}

package/embedded/storage/flash.d.ts

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2025  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ *
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+declare module "embedded:storage/flash" {
+	export interface FlashOpenOptions {
+		path: string;
+		mode?: "r" | "r+";
+	}
+
+	export interface FlashStatus {
+		size: number;
+		blockLength: number;
+		blocks: number;
+		writeAlign: number;
+		eraseValue: number;
+	}
+
+	export class Flash {
+		// Use the default export's open() method to create Flash instances
+		close(): void;
+
+		eraseBlock(start: number, end?: number): void;
+
+		read(byteLength: number, byteOffset: number): ArrayBuffer;
+		read(buffer: BufferLike, byteOffset: number): number;
+		write(buffer: BufferLike, byteOffset: number): void;
+
+		status(): FlashStatus;
+
+		format: "buffer";
+	}
+
+	const FlashStorage: {
+		open(options: FlashOpenOptions): Flash;
+		[Symbol.iterator](): IterableIterator<string>;
+	};
+
+	export default FlashStorage;
+}

package/embedded/storage/key-value.d.ts

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2024-2025  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ *
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+declare module "embedded:storage/key-value" {
+	export interface StorageOpenOptions {
+		path: string;
+		mode?: "r" | "r+";
+	}
+
+	export type StorageFormat = "buffer" | "string" | "uint8" | "int8" | "uint16" | "int16" | "uint32" | "int32" | "uint64" | "int64";
+
+	export class Storage {
+		// Use the default export's open() method to create Storage instances
+		close(): void;
+
+		delete(key: string): void;
+
+		read(key: string): ArrayBuffer | string | number | bigint;
+		read(key: string, buffer: BufferLike): number;
+		write(key: string, value: BufferLike | string | number | bigint): void;
+
+		[Symbol.iterator](): IterableIterator<string>;
+
+		format: StorageFormat;
+	}
+
+	const KeyValueStorage: {
+		open(options: StorageOpenOptions): Storage;
+	};
+
+	export default KeyValueStorage;
+}

package/embedded_io/ble/_common.d.ts

@@ -0,0 +1,14 @@
+declare module "embedded:io/bluetoothle/_common" {
+	export interface GATTSecurityOptions {
+		bond?: boolean,
+		authenticate?: boolean,
+		ioCapabilities?: "none" | "display" | "numbers" | "display+numbers" | "display+confirm",
+		immediate?: boolean
+	}
+	export interface GATTSecurityState {
+		encrypted: boolean,
+		authenticated: boolean,
+		bonded: boolean,
+		keySize: number
+	}
+}

package/embedded_io/ble/{client.d.ts → central.d.ts}

@@ -1,5 +1,6 @@
 declare module "embedded:io/bluetoothle/central" {
-    import { Buffer } from "embedded:io/_common";
+	import type { Buffer } from "embedded:io/_common";
+	import type { GATTSecurityOptions, GATTSecurityState } from "embedded:io/bluetoothle/_common";
 
     interface Advertisement {
         address: string;
@@ -32,25 +33,11 @@ declare module "embedded:io/bluetoothle/central" {
         response?: boolean
     }
 
-    interface GATTSecurityOptions {
-        bond?: boolean,
-        authenticate?: boolean,
-        ioCapabilities?: "none" | "display" | "numbers" | "display+numbers" | "display+confirm",
-        immediate?: boolean
-    }
-
-    interface GATTSecurityState {
-        encrypted: boolean,
-        authenticated: boolean,
-        bonded: boolean,
-        keySize: number
-    }
-
     interface GATTClientOptions {
         address: string,
         target?: any;
         security?: GATTSecurityOptions;
-        onReady?: (this: GATTClient, ) => void;
+        onReady?: (this: GATTClient,) => void;
         onPasskey?: (this: GATTClient, action: string, data: number | ArrayBuffer | undefined) => void;
         onSecured?: (this: GATTClient, state: GATTSecurityState) => void;
         onError?: (this: GATTClient, error: Error) => void;
@@ -88,20 +75,20 @@ declare module "embedded:io/bluetoothle/central" {
 
         read(what: GATTClientCharacteristic | GATTClientDescriptor, callback: (error: Error | null, value: ArrayBuffer) => void): void;
         read(what: GATTClientCharacteristic | GATTClientDescriptor, options: object, callback: (error: Error | null, value: ArrayBuffer) => void): void;
-        read() : undefined | GATTClientNotifiedValue;
+        read(): undefined | GATTClientNotifiedValue;
 
-        write(what: GATTClientCharacteristic | GATTClientDescriptor, value: Buffer, callback?: (error: Error | null) => void): void;
-        write(what: GATTClientCharacteristic | GATTClientDescriptor, value: Buffer, options: GATTClientWriteOptions, callback?: (error: Error | null) => void): void;
+        write(what: GATTClientCharacteristic | GATTClientDescriptor, value: BufferLike, callback?: (error: Error | null) => void): void;
+        write(what: GATTClientCharacteristic | GATTClientDescriptor, value: BufferLike, options: GATTClientWriteOptions, callback?: (error: Error | null) => void): void;
 
-        subscribe(characteristic: GATTClientCharacteristic, callback?: (error?: Error) => void) : void;
-        unsubscribe(characteristic: GATTClientCharacteristic, callback?: (error?: Error) => void) : void;
+        subscribe(characteristic: GATTClientCharacteristic, callback?: (error?: Error) => void): void;
+        unsubscribe(characteristic: GATTClientCharacteristic, callback?: (error?: Error) => void): void;
 
-        replyToPasskey(action: string, data?: number | ArrayBuffer) : void;
+        replyToPasskey(action: string, data?: number | ArrayBuffer): void;
 
         get maximumWrite(): number;
 
         store(item: GATTClientService | GATTClientCharacteristic | GATTClientDescriptor): ArrayBuffer;
-        restore(item: Buffer): GATTClientService | GATTClientCharacteristic | GATTClientDescriptor;
+        restore(item: BufferLike): GATTClientService | GATTClientCharacteristic | GATTClientDescriptor;
 
         static readonly properties: {
             authenticatedSignedWrites: 64;
@@ -116,4 +103,4 @@ declare module "embedded:io/bluetoothle/central" {
     }
  
     export { GATTClient, GAPClient };
-}
+}

package/embedded_io/ble/peripheral.d.ts

@@ -0,0 +1,92 @@
+declare module "embedded:io/bluetoothle/peripheral" {
+    import type { Buffer } from "embedded:io/_common";
+    import type { GATTSecurityOptions, GATTSecurityState } from "embedded:io/bluetoothle/_common";
+
+    interface GATTServerOptions {
+        mtu?: number;
+        services: GATTServerService[];
+        security?: GATTSecurityOptions;
+        onReady?(this: GATTServer): void;
+        onConnect?(this: GATTServer, connection: GATTServerConnection): void;
+        onDisconnect?(this: GATTServer, connection: GATTServerConnection): void;
+        onPasskey?(this: GATTServer, connection: GATTServerConnection, action: "input" | "display" | "compareNumber" | "outOfBand", data?: number | ArrayBuffer): void;
+        onSecured?(this: GATTServer, connection: GATTServerConnection, state: GATTSecurityState): void;
+        onWarning?(this: GATTServer, message: string): void;
+    }
+
+    interface GATTServerConnection {
+        close(): void;
+        notify(characteristic: GATTServerCharacteristic, value: ArrayBuffer, callback?: (error?: Error) => void): void;
+        replyToPasskey(action: "input" | "compareNumber" | "outOfBand", value: number | boolean | ArrayBuffer): void;
+        get maxinumWrite(): number;
+    }
+
+    interface GATTServerService {
+        uuid: string;
+        characteristics?: GATTServerCharacteristic[];
+    }
+
+    interface GATTServerCharacteristic {
+        uuid: string;
+        properties?: number;
+        value?: Buffer;
+        descriptors?: GATTServerDescriptor[];
+
+        onRead?(this: GATTServerCharacteristic, connection: GATTServerConnection): Buffer;
+        onWrite?(this: GATTServerCharacteristic, value: ArrayBuffer, connection: GATTServerConnection): void;
+        onSubscribe?(this: GATTServerCharacteristic, connection: GATTServerConnection): void;
+        onUnsubscribe?(cthis: GATTServerCharacteristic, onnection: GATTServerConnection): void;
+    }
+
+    interface GATTServerDescriptor {
+        uuid: string;
+        value?: Buffer;
+
+        onRead?(connection: GATTServerConnection): Buffer;
+        onWrite?(value: ArrayBuffer, connection: GATTServerConnection): void;
+    }
+
+    interface GATTServerAdvertisingRecords {
+        name?: string;
+        services?: string[];
+        manufacturerData?: { manufacturer: number, data: Buffer };
+        flags?: number;
+        [ADType: number]: Buffer;
+    }
+
+    class GATTServer {
+        constructor(options: GATTServerOptions);
+
+        close?(): void;
+        addService(service: GATTServerService): void;
+        deleteService(service: GATTServerService): void;
+        startAdvertising(scan: GATTServerAdvertisingRecords, response?: GATTServerAdvertisingRecords): void;
+        stopAdvertising(): void;
+
+        static readonly properties: {
+            authenticatedSignedWrites: 64;
+            broadcast: 1;
+            indicate: 32;
+            notify: 16;
+            read: 2;
+            readAuthenticated: 1026;
+            readEncrypted: 514;
+            reliableWrite: 128;
+            subscribeAuthenticated: 65552;
+            subscribeEncrypted: 32784;
+            write: 8;
+            writeAuthenticated: 8200;
+            writeEncrypted: 4104;
+            writeWithOutResponse: 4;
+        };
+        static readonly advertise: {
+            limitedDiscoverable: 1;
+            generalDiscoverable: 2;
+            bleOnly: 4;
+            dualModeController: 8;
+            dualModeHost: 16;
+        }
+    }
+
+    export { GATTServer };
+}

package/embedded_io/digital.d.ts

@@ -30,14 +30,16 @@ declare module "embedded:io/digital" {
     | typeof Digital.InputPullUpDown
     | typeof Digital.Output
     | typeof Digital.OutputOpenDrain
+    | typeof Digital.ActiveLow
 
   class Digital {
-    static readonly Input: unknown
-    static readonly InputPullUp: unknown
-    static readonly InputPullDown: unknown
-    static readonly InputPullUpDown: unknown
-    static readonly Output: unknown
-    static readonly OutputOpenDrain: unknown
+    static readonly Input: number
+    static readonly InputPullUp: number
+    static readonly InputPullDown: number
+    static readonly InputPullUpDown: number
+    static readonly Output: number
+    static readonly OutputOpenDrain: number
+    static readonly ActiveLow: number
     static readonly Rising: Edge;
     static readonly Falling: Edge;
 

package/embedded_io/digitalbank.d.ts

@@ -26,14 +26,16 @@ declare module "embedded:io/digitalbank" {
     | typeof DigitalBank.InputPullUpDown
     | typeof DigitalBank.Output
     | typeof DigitalBank.OutputOpenDrain
+    | typeof DigitalBank.ActiveLow
 
   class DigitalBank {
-    static readonly Input: unknown
-    static readonly InputPullUp: unknown
-    static readonly InputPullDown: unknown
-    static readonly InputPullUpDown: unknown
-    static readonly Output: unknown
-    static readonly OutputOpenDrain: unknown
+    static readonly Input: number
+    static readonly InputPullUp: number
+    static readonly InputPullDown: number
+    static readonly InputPullUpDown: number
+    static readonly Output: number
+    static readonly OutputOpenDrain: number
+    static readonly ActiveLow: number
 
     constructor(dictionary: {
       pins: number;

package/embedded_network/interface/ethernet.d.ts

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2025  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ *
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+declare module "embedded:network/interface/ethernet" {
+	import type {PortSpecifier} from "embedded:io/_common";
+
+	export interface EthernetConstructorOptions {
+		port?: PortSpecifier;
+		onChanged?: () => void;
+	}
+
+	class Ethernet {
+		constructor(options: EthernetConstructorOptions);
+
+		close(): void;
+		connect(options: {}): void;
+		disconnect(): void;
+
+		readonly connection: number;
+		readonly address: string | undefined;
+		readonly MAC: string | undefined;
+	}
+
+	export default Ethernet;
+}

package/embedded_network/interface/wifi.d.ts

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2025  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ *
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+declare module "embedded:network/interface/wifi" {
+	import type {PortSpecifier} from "embedded:io/_common";
+
+	export interface WiFiConstructorOptions {
+		port?: PortSpecifier;
+		onChanged?: () => void;
+	}
+
+	export interface WiFiScanResult {
+		SSID: string;
+		channel: number;
+		RSSI: number;
+		BSSID?: ArrayBuffer;
+	}
+
+	export interface WiFiScanOptions {
+		onFound?: (result: WiFiScanResult) => void;
+		onComplete?: () => void;
+	}
+
+	export interface WiFiConnectOptions {
+		SSID: string;
+		password?: string;
+	}
+
+	class WiFi {
+		constructor(options: WiFiConstructorOptions);
+
+		close(): void;
+		scan(options: WiFiScanOptions): void;
+		connect(options: WiFiConnectOptions): void;
+		disconnect(): void;
+
+		readonly connection: number;
+		readonly address: string | undefined;
+		readonly MAC: string | undefined;
+	}
+
+	export default WiFi;
+}

package/embedded_network/mqtt/client.d.ts

@@ -53,7 +53,8 @@ declare module "embedded:network/mqtt/client" {
   export default class MQTTClient {
     constructor(options: Options)
     read(count: number): ArrayBuffer
-    write(data: Buffer, options: WriteOptions): number
+    read(buffer: BufferLike): number
+    write(data: BufferLike, options: WriteOptions): number
     close(): void
 
     static CONNECT: 1

package/embedded_network/ntp/client.d.ts

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2025  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ * 
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ * 
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ * 
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+declare module "embedded:network/ntp/client" {
+	import type UDP from "embedded:io/socket/udp";
+	import type Resolver from "embedded:network/dns/resolver/udp";
+	
+	export interface NTPOptions<T = any> {
+		servers: string[];
+		socket: { io: typeof UDP };
+		dns: { io: typeof Resolver };
+		target?: T;
+	}
+	
+	export interface NTPCallback {
+		(error: null, time: number): void;
+		(error: Error): void;
+	}
+	
+	export default class NTP<T = any> {
+		target?: T;
+		constructor(options: NTPOptions<T>);
+		close(): void;
+		getTime(callback: NTPCallback): void;
+	}
+}

package/neopixel.d.ts

@@ -0,0 +1,43 @@
+/*
+* Copyright (c) 2025 Satoshi Tanaka
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "neopixel" {
+    class NeoPixel extends HostBuffer {
+        constructor(options?: {
+            pin?: number,
+            length?: number,
+            order?: string
+        });
+
+        close(): void;
+        update(): void;
+
+        makeRGB(r: number, g: number, b: number): number;
+        makeHSB(h: number, s: number, b: number): number;
+        setPixel(index: number, color: number): void;
+        fill(color: number, index?: number, count?: number): void;
+        getPixel(index: number): number;
+
+        get brightness(): number;
+        set brightness(value: number);
+        get length(): number;
+    }
+    export default NeoPixel;
+}

package/neostrand.d.ts

@@ -0,0 +1,173 @@
+/*
+* Copyright (c) 2025 Satoshi Tanaka
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "neostrand" {
+    import type NeoPixel from "neopixel";
+    import type Timeline from "piu/Timeline";
+
+    export type NeoStrandEffectDictionary = {
+        strand: NeoStrand;
+        start?: number;
+        end?: number;
+        reverse?: 0 | 1;
+        duration?: number;
+        position?: number;
+        speed?: number;
+        size?: number;
+        loop?: 0 | 1;
+        tickle?: number;
+
+        onComplete?: (effect: NeoStrandEffect) => void;
+    }
+
+    export class NeoStrandEffect {
+        name: string;
+        strand: NeoStrand;
+        start: number;
+        end: number
+        size: number;
+        dur: number;
+        reverse: 0 | 1;
+        loop: 0 | 1;
+        timeline: Timeline;
+        constructor(dictionary: NeoStrandEffectDictionary);
+
+        reset(effect: NeoStrandEffect): void;
+        loopPrepare(effect: NeoStrandEffect): void;
+        activate(effect: NeoStrandEffect): void;
+        idle(effect: NeoStrandEffect, ticks: number): void;
+    }
+
+    class HueSpan extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            position?: number;
+            saturation?: number;
+            value?: number;
+        });
+
+        set hue(h: number);
+    }
+
+    class Sine extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            amplitude?: number;
+            offset?: number;
+            vary?: "r" | "g" | "b" | "h" | "s" | "v";
+        });
+
+        set effectValue(value: number);
+    }
+
+    interface rgb {
+        r: number;
+        g: number;
+        b: number;
+    }
+    class Marquee extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            sizeA?: number;
+            sizeB?: number;
+            rgbA?: rgb;
+            rgbB?: rgb;
+        });
+
+        set steps(s: number);
+    }
+
+    class Pulse extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            dir?: number;
+            mode?: -1 | 0 | 1;
+            fade?: number;
+            size?: number;
+            duration?: number;
+            position?: "random" | number;
+            rgb?: rgb;
+        });
+
+        loopPrepare(effect: NeoStrandEffect): void;
+        set pulseLoc(px: number);
+    }
+
+    class Pattern extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            pattern?: number[];
+            mode?: -1 | 0 | 1;
+        });
+
+        loopPrepare(effect: NeoStrandEffect): void;
+        set effectValue(value: number);
+    }
+
+    class Dim extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            rgb?: rgb;
+        });
+    }
+
+    class Ease extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            easing?: number;
+            size?: number;
+            rgb?: rgb;
+        });
+
+        set steps(s: number);
+    }
+
+    interface PulseTiming {
+        level0: 0 | 1;
+        duration0: number;
+        level1: 0 | 1;
+        duration1: number;
+    }
+
+    export class NeoStrand extends NeoPixel {
+        constructor(options?: {
+            pin?: number,
+            length?: number,
+            order?: string,
+            timing?: {
+                mark: PulseTiming,
+                space: PulseTiming,
+                reset: PulseTiming
+            }
+        });
+
+        set(idx: number, color: number, start?: number, end?: number): void;
+        add(idx: number, color: number, start?: number, end?: number): void;
+        sub(idx: number, color: number, start?: number, end?: number): void;
+        op(idx: number, rgb: number, mode: number, start: number, end: number): void;
+        setScheme(scheme: NeoStrandEffect[]): void;
+        start(ms?: number): void;
+        stop(): void;
+        hsvToRgb(h: number, s: number, v: number): number;
+        rgbToHsv(r: number, g: number, b: number): { h: number; s: number; v: number };
+
+        static HueSpan: typeof HueSpan;
+        static Sine: typeof Sine;
+        static Marquee: typeof Marquee;
+        static Pulse: typeof Pulse;
+        static Pattern: typeof Pattern;
+        static Dim: typeof Dim;
+        static Ease: typeof Ease;
+    }
+    
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@moddable/typings",
-	"version": "6.1.0",
+	"version": "7.0.0",
 	"main": "",
 	"types": [
 		"xs.d.ts",