@moddable/typings 6.1.0 → 7.1.0

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

@@ -1,5 +1,5 @@
 declare module "embedded:io/bluetoothle/central" {
-    import { Buffer } from "embedded:io/_common";
+	import type { GATTSecurityOptions, GATTSecurityState } from "embedded:io/bluetoothle/_common";
 
     interface Advertisement {
         address: string;
@@ -32,25 +32,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 +74,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: ByteBuffer, callback?: (error: Error | null) => void): void;
+        write(what: GATTClientCharacteristic | GATTClientDescriptor, value: ByteBuffer, 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: ByteBuffer): GATTClientService | GATTClientCharacteristic | GATTClientDescriptor;
 
         static readonly properties: {
             authenticatedSignedWrites: 64;
@@ -116,4 +102,4 @@ declare module "embedded:io/bluetoothle/central" {
     }
  
     export { GATTClient, GAPClient };
-}
+}

package/embedded_io/ble/peripheral.d.ts

@@ -0,0 +1,91 @@
+declare module "embedded:io/bluetoothle/peripheral" {
+    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?: ByteBuffer;
+        descriptors?: GATTServerDescriptor[];
+
+        onRead?(this: GATTServerCharacteristic, connection: GATTServerConnection): ByteBuffer;
+        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?: ByteBuffer;
+
+        onRead?(connection: GATTServerConnection): ByteBuffer;
+        onWrite?(value: ArrayBuffer, connection: GATTServerConnection): void;
+    }
+
+    interface GATTServerAdvertisingRecords {
+        name?: string;
+        services?: string[];
+        manufacturerData?: { manufacturer: number, data: ByteBuffer };
+        flags?: number;
+        [ADType: number]: ByteBuffer;
+    }
+
+    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_io/i2c.d.ts

@@ -20,7 +20,7 @@
 
 
 declare module "embedded:io/i2c" {
-  import { Buffer, PinSpecifier, PortSpecifier } from "embedded:io/_common";
+  import { PinSpecifier, PortSpecifier } from "embedded:io/_common";
   class I2C {
     constructor(options: {
       data: PinSpecifier;
@@ -33,9 +33,9 @@ declare module "embedded:io/i2c" {
     });
     readonly resolution: number;
     
-    write(value: Buffer, stop?: boolean): void;
+    write(value: ByteBuffer, stop?: boolean): void;
     read(byteLength: number, stop?: boolean): ArrayBuffer;
-    read(buffer: Buffer, stop?: boolean): ArrayBuffer;
+    read(buffer: ByteBuffer, stop?: boolean): number;
     get format(): "buffer"
     set format(value: "buffer")
   }

package/embedded_io/serial.d.ts

@@ -19,7 +19,7 @@
 */
 
 declare module "embedded:io/serial" {
-  import { Buffer, PinSpecifier, PortSpecifier } from "embedded:io/_common";
+  import { PinSpecifier, PortSpecifier } from "embedded:io/_common";
   class Serial {
     constructor(options: ({
       receive: PinSpecifier;
@@ -44,8 +44,8 @@ declare module "embedded:io/serial" {
     close(): void;
     read(): number | ArrayBuffer | undefined;
     read(byteLength: number): ArrayBuffer | undefined;
-    read(buffer: Buffer): number | undefined;
-    write(value: number | Buffer): void;
+    read(buffer: ByteBuffer): number | undefined;
+    write(value: number | ByteBuffer): void;
     flush(): void;
     flush(input: number, output: number): void;
     set(options: {

package/embedded_io/smbus.d.ts

@@ -20,7 +20,6 @@
 
 declare module "embedded:io/smbus" {
   import I2C from "embedded:io/i2c"
-  import { Buffer } from "embedded:io/_common";
 
   class SMBus extends I2C {
     constructor(options: ConstructorParameters<typeof I2C> & {
@@ -31,8 +30,8 @@ declare module "embedded:io/smbus" {
     readUint16(register: number, bigEndian?: boolean): number;
     writeUint16(register: number, value: number, bigEndian?: boolean): void;
     readBuffer(register: number, byteLength: number): ArrayBuffer;
-    readBuffer(register: number, buffer: Buffer): void;
-    writeBuffer(register: number, buffer: Buffer): void;
+    readBuffer(register: number, buffer: ByteBuffer): void;
+    writeBuffer(register: number, buffer: ByteBuffer): void;
     readQuick(): void;
     writeQuick(): void;
     receiveByte(): number;

package/embedded_io/socket/tcp.d.ts

@@ -19,7 +19,6 @@
 */
 
 declare module "embedded:io/socket/tcp" {
-  import type { Buffer } from "embedded:io/_common";
   export type Options = ((({
     address: string;
   } | {
@@ -42,8 +41,8 @@ declare module "embedded:io/socket/tcp" {
     readonly remoteAddress: string | undefined;
     readonly remotePort: number | undefined;
     read(byteLength?: number): number | ArrayBuffer;
-    read(buffer: Buffer): void;
-    write(value: number | Buffer): void;
+    read(buffer: ByteBuffer): void;
+    write(value: number | ByteBuffer): void;
     close(): void;
     get format(): "number" | "buffer"
     set format(value: "number" | "buffer")

package/embedded_io/socket/udp.d.ts

@@ -19,7 +19,6 @@
 */
 
 declare module "embedded:io/socket/udp" {
-  import type { Buffer } from "embedded:io/_common";
   class UDP {
     constructor(options: {
       port?: number;
@@ -32,7 +31,7 @@ declare module "embedded:io/socket/udp" {
       multicast: string;
       timeToLive: number;
     }))
-    write(buffer: Buffer, address: string, port: number): void;
+    write(buffer: ByteBuffer, address: string, port: number): void;
     read(): ArrayBuffer & {
       address: string;
       port: number;

package/embedded_io/spi.d.ts

@@ -19,7 +19,7 @@
 */
 
 declare module "embedded:io/spi" {
-  import { Buffer, PinSpecifier, PortSpecifier } from "embedded:io/_common";
+  import { PinSpecifier, PortSpecifier } from "embedded:io/_common";
   class SPI {
     constructor(options: {
       out?: PinSpecifier;
@@ -34,9 +34,9 @@ declare module "embedded:io/spi" {
       target?: any;
     })
     read(byteLength: number): ArrayBuffer;
-    read(buffer: Buffer): void;
-    write(buffer: Buffer): void;
-    transfer(buffer: Buffer): void;
+    read(buffer: ByteBuffer): void;
+    write(buffer: ByteBuffer): void;
+    transfer(buffer: ByteBuffer): void;
     flush(deselect?: boolean): void;
     get format(): "buffer";
     set format(value: "buffer");

package/embedded_network/http/client.d.ts

@@ -19,8 +19,6 @@
 */
 
 declare module "embedded:network/http/client" {
-  import type { Buffer } from "embedded:io/_common"
-
   export interface ClientOptions {
     socket: any
     port?:number
@@ -41,8 +39,8 @@ declare module "embedded:network/http/client" {
 
   export interface HTTPRequest {
     read(byteLength?: number): ArrayBuffer|undefined;
-    read(buffer: Buffer): void;
-    write(value: Buffer|undefined): void;
+    read(buffer: ByteBuffer): void;
+    write(value: ByteBuffer|undefined): void;
   }
 
   export default class HTTPClient {

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

@@ -1,6 +1,4 @@
 declare module "embedded:network/mqtt/client" {
-  import type { Buffer } from "embedded:io/_common"
-
   interface onReadableOptions {
     more: boolean,
     topic?: string,
@@ -11,12 +9,12 @@ declare module "embedded:network/mqtt/client" {
   interface onControlMessage {
     operation: number, // MQTTClient.CONNACK, etc...
     id: number, 
-    payload?: Buffer, // for SUBACK
+    payload?: ByteBuffer, // for SUBACK
   }
 
   interface Will {
     topic?: string,
-    message?: string|Buffer,
+    message?: string | ByteBuffer,
     QoS?: number,
     retain?: boolean,
   }
@@ -53,7 +51,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: ByteBuffer): number
+    write(data: ByteBuffer, 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/flash.d.ts

@@ -24,7 +24,7 @@ declare module "flash" {
     constructor(offset: number, byteLength: number);
     erase(sector: number): void;
     read(offset: number, byteLength: number, useHostBuffer?: boolean): ArrayBuffer | HostBuffer;
-    write(offset: number, byteLength: number, buffer: BufferLike): void;
+    write(offset: number, byteLength: number, buffer: ByteBuffer): void;
     readonly byteLength: number;
     readonly blockSize: number;
     map(): HostBuffer;

package/hex.d.ts

@@ -21,7 +21,7 @@
 declare module "hex" {
   var Hex: {
     toBuffer: (str: string, separator?: string) => ArrayBuffer;
-    toString: (buffer: BufferLike, separator?: string) => string;
+    toString: (buffer: ByteBuffer, separator?: string) => string;
   }
   export {Hex as default};
 }

package/inflate.d.ts

@@ -24,7 +24,7 @@ declare module "inflate" {
     constructor(options?: {windowBits?: number});
     close(): void;
 
-    push(buffer: BufferLike, end?: boolean): number;
+    push(buffer: ByteBuffer, end?: boolean): number;
 
     onData: (data: ArrayBuffer) => void;
     onEnd: (status: number) => 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;
+}