mqtt-plus 0.9.17 → 1.0.0

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 ChangeLog
 =========
 
+1.0.0 (2026-01-25)
+------------------
+
+- CLEANUP: various code cleanups
+
+0.9.18 (2026-01-25)
+-------------------
+
+- IMPROVEMENT: support config parameter API variant also in subscribe/register/provision
+- IMPROVEMENT: support MQTT 5 shared subscriptions also in subscribe/register/provision
+
 0.9.17 (2026-01-25)
 -------------------
 

package/README.md

@@ -113,12 +113,16 @@ const mqttp = new MQTTp<API>(mqtt)
 
 mqtt.on("connect", async () => {
     await mqttp.subscribe("example/sample", (a1, a2, info) => {
-        console.log("example/sample:", a1, a2, "from:", info.sender)
+        console.log("example/sample: SERVER:", a1, a2, info.sender)
     })
     await mqttp.register("example/hello", (a1, a2, info) => {
-        console.log("example/hello:", a1, a2, "from:", info.sender)
+        console.log("example/hello: SERVER:", a1, a2, info.sender)
         return `${a1}:${a2}`
     })
+    await mqttp.provision("example/resource", async (filename, info) => {
+        console.log("example/resource: SERVER:", filename, info.sender)
+        info.buffer = Promise.resolve(new TextEncoder().encode(`the ${filename} content`))
+    })
 })
 ```
 
@@ -132,12 +136,17 @@ import type { API } from [...]
 const mqtt = MQTT.connect("wss://127.0.0.1:8883", { [...] })
 const mqttp = new MQTTp<API>(mqtt)
 
-mqtt.on("connect", () => {
+mqtt.on("connect", async () => {
     mqttp.emit("example/sample", "world", 42)
-    mqttp.call("example/hello", "world", 42).then((response) => {
-        console.log("example/hello response:", response)
-        mqtt.end()
-    })
+
+    const response = await mqttp.call("example/hello", "world", 42)
+    console.log("example/hello CLIENT:", response)
+
+    const result = await mqttp.fetch("example/resource", "foo")
+    const data = new TextDecoder().decode(await result.buffer)
+    console.log("example/resource CLIENT:", data)
+
+    mqtt.end()
 })
 ```
 
@@ -148,8 +157,13 @@ The **MQTT+** API provides the following methods:
 
 - **Construction**:<br/>
 
-      constructor<API>(
-          mqtt: MqttClient,
+      /*  (simplified TypeScript API method signature)  */
+      constructor<API extends Record<string,
+          Event<   (...args: any[]) => void | Promise<void>> |
+          Service< (...args: any[]) => any  | Promise<any> > |
+          Resource<(...args: any[]) => void | Promise<void>>
+      >>(
+          mqtt: MqttClient | null,
           options?: {
               id:         string
               codec:      "cbor" | "json"
@@ -160,19 +174,16 @@ The **MQTT+** API provides the following methods:
           }
       )
 
-  The `API` is an optional TypeScript type `Record<string, ((...args:
-  any[]) => void) | ((...args: any[]) => any)>`, describing the
-  available events and services. Callbacks without return values
-  describe events, callbacks with return values describe services.
-
+  The `API` is an optional TypeScript type,
+  describing the available events, services and resources.
   The `mqtt` is the [MQTT.js](https://www.npmjs.com/package/mqtt) instance,
-  which has to be established separately.
-
-  Use `destroy()` to clean up when the instance is no longer needed.
+  which has to be established separately. A `null` MQTT instance can be
+  used for performing dry-runs (see *Dry-Run Publishing for MQTT Last-Will* under
+  **Event Emission** below).
 
   The optional `options` object supports the following fields:
   - `id`: Custom MQTT peer identifier (default: auto-generated NanoID).
-  - `codec`: Encoding format (default: `cbor`).
+  - `codec`: Encoding format, either `cbor` or `json` (default: `cbor`).
   - `timeout`: Communication timeout in milliseconds (default: `10000`).
   - `chunkSize`: Chunk size in bytes for resource transfers (default: `16384`).
   - `topicMake`: Custom topic generation function.
@@ -195,18 +206,29 @@ The **MQTT+** API provides the following methods:
       /*  (simplified TypeScript API method signature)  */
       subscribe(
           event:    string,
-          options?: MQTT::IClientSubscribeOptions
           callback: (
               ...params: any[],
               info: { sender: string, receiver?: string }
           ) => void | Promise<void>
       ): Promise<Subscription>
+      subscribe({
+          event:    string,
+          callback: (
+              ...params: any[],
+              info: { sender: string, receiver?: string }
+          ) => void | Promise<void>,
+          options?: MQTT::IClientSubscribeOptions,
+          share?:   string
+      }): Promise<Subscription>
 
   Subscribe to an event.
   The `event` has to be a valid MQTT topic name.
-  The optional `options` allows setting MQTT.js `subscribe()` options like `qos`.
   The `callback` is called with the `params` passed to a remote `emit()`.
   There is no return value of `callback`.
+  The optional `options` allows setting MQTT.js `subscribe()` options like `qos`.
+  The optional `share` enables [MQTT Shared Subscriptions](https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901250)
+  (MQTT 5.0) for load-balancing messages across multiple subscribers by specifying
+  a group name. This internally prefixes the event with `$share/<share>/`.
 
   Internally, on the MQTT broker, the topics generated by
   `topicMake(event, "event-emission")` (default: `${event}/event-emission/any` and
@@ -218,18 +240,29 @@ The **MQTT+** API provides the following methods:
       /*  (simplified TypeScript API method signature)  */
       register(
           service:  string,
-          options?: MQTT::IClientSubscribeOptions
           callback: (
               ...params: any[],
               info: { sender: string, receiver?: string }
           ) => any | Promise<any>
       ): Promise<Registration>
+      register({
+          service:  string,
+          callback: (
+              ...params: any[],
+              info: { sender: string, receiver?: string }
+          ) => any | Promise<any>,
+          options?: MQTT::IClientSubscribeOptions,
+          share?:   string
+      }): Promise<Registration>
 
   Register a service.
   The `service` has to be a valid MQTT topic name.
-  The optional `options` allows setting MQTT.js `subscribe()` options like `qos`.
   The `callback` is called with the `params` passed to a remote `call()`.
   The return value of `callback` will resolve the `Promise` returned by the remote `call()`.
+  The optional `options` allows setting MQTT.js `subscribe()` options like `qos`.
+  The optional `share` enables [MQTT Shared Subscriptions](https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901250)
+  (MQTT 5.0) for load-balancing service calls across multiple registrants by specifying
+  a group name. This internally prefixes the service with `$share/<share>/`.
 
   Internally, on the MQTT broker, the topics generated by
   `topicMake(service, "service-call-request")` (default: `${service}/service-call-request/any` and
@@ -241,30 +274,47 @@ The **MQTT+** API provides the following methods:
       /*  (simplified TypeScript API method signature)  */
       provision(
           resource: string,
-          options?: MQTT::IClientSubscribeOptions
           callback: (
               ...params: any[],
               info: {
-                  sender: string,
+                  sender:    string,
                   receiver?: string,
-                  meta?: Record<string, any>,
-                  stream?: Readable,
-                  buffer?: Promise<Buffer>
+                  meta?:     Record<string, any>,
+                  stream?:   Readable,
+                  buffer?:   Promise<Uint8Array>
               }
           ) => void | Promise<void>
       ): Promise<Provisioning>
+      provision({
+          resource: string,
+          callback: (
+              ...params: any[],
+              info: {
+                  sender:    string,
+                  receiver?: string,
+                  meta?:     Record<string, any>,
+                  stream?:   Readable,
+                  buffer?:   Promise<Uint8Array>
+              }
+          ) => void | Promise<void>,
+          options?: MQTT::IClientSubscribeOptions,
+          share?:   string
+      }): Promise<Provisioning>
 
   Provision a resource for both fetch requests and pushed data.
   The `resource` has to be a valid MQTT topic name.
   The optional `options` allows setting MQTT.js `subscribe()` options like `qos`.
+  The optional `share` enables [MQTT Shared Subscriptions](https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901250)
+  (MQTT 5.0) for load-balancing resource requests across multiple provisioners by specifying
+  a group name. This internally prefixes the resource with `$share/<share>/`.
 
   For **fetch requests**: The `callback` is called with the `params` passed to a remote `fetch()`.
-  The `callback` should set `info.stream` to a `Readable` or `info.buffer` to a `Promise<Buffer>` containing the resource data.
+  The `callback` should set `info.stream` to a `Readable` or `info.buffer` to a `Promise<Uint8Array>` containing the resource data.
   Optionally, the `callback` can set `info.meta` to a `Record<string, any>` to send metadata back with the response.
 
   For **pushed data**: The `callback` is called with the `params` passed to a remote `push()`.
   The `info.stream` provides a Node.js `Readable` stream for consuming the pushed data.
-  The `info.buffer` provides a lazy `Promise<Buffer>` that resolves to the complete data once the stream ends.
+  The `info.buffer` provides a lazy `Promise<Uint8Array>` that resolves to the complete data once the stream ends.
   The `info.meta` contains optional metadata sent by the pusher via `push()`.
 
   Internally, on the MQTT broker, the topics by
@@ -292,7 +342,7 @@ The **MQTT+** API provides the following methods:
           receiver?: string,
           options?:  MQTT::IClientSubscribeOptions,
           dry:       true
-      }): { topic: string, payload: Buffer, options: IClientPublishOptions }
+      }): { topic: string, payload: Uint8Array, options: IClientPublishOptions }
 
   Emit an event to all subscribers or a specific subscriber ("fire and forget").
   The optional `receiver` directs the event to a specific subscriber only.
@@ -307,7 +357,7 @@ The **MQTT+** API provides the following methods:
   Internally, publishes to the MQTT topic by `topicMake(event, "event-emission", peerId)`
   (default: `${event}/event-emission/any` or `${event}/event-emission/${peerId}`).
 
-  **Dry-Run Publishing for MQTT Last-Will:**
+  *Dry-Run Publishing for MQTT Last-Will:*
   When you need to set up an MQTT "last will" message (automatically published
   by the broker when a client disconnects *unexpectedly*), you can use `dry: true`
   together with a `null` MQTT client:
@@ -367,7 +417,7 @@ The **MQTT+** API provides the following methods:
           ...params: any[]
       ): Promise<{
           stream:    Readable,
-          buffer:    Promise<Buffer>,
+          buffer:    Promise<Uint8Array>,
           meta:      Promise<Record<string, any> | undefined>
       }>
       fetch({
@@ -377,7 +427,7 @@ The **MQTT+** API provides the following methods:
           options?:  MQTT::IClientSubscribeOptions
       }): Promise<{
           stream:    Readable,
-          buffer:    Promise<Buffer>,
+          buffer:    Promise<Uint8Array>,
           meta:      Promise<Record<string, any> | undefined>
       }>
 
@@ -386,12 +436,12 @@ The **MQTT+** API provides the following methods:
   The optional `options` allows setting MQTT.js `publish()` options like `qos` or `retain`.
 
   Returns an object with a `stream` (`Readable`) for consuming the transferred data,
-  a lazy `buffer` (`Promise<Buffer>`) that resolves to the complete data once the stream ends,
+  a lazy `buffer` (`Promise<Uint8Array>`) that resolves to the complete data once the stream ends,
   and a `meta` (`Promise<Record<string, any> | undefined>`) that resolves to optional metadata
   sent by the provisioner when the first chunk arrives.
 
   The remote `provision()` `callback` is called with `params` and
-  should set `info.stream` to a `Readable` or `info.buffer` to a `Promise<Buffer>` containing the resource data.
+  should set `info.stream` to a `Readable` or `info.buffer` to a `Promise<Uint8Array>` containing the resource data.
   Optionally, the `callback` can set `info.meta` to send metadata back with the response.
   If the remote `callback` throws an exception, this destroys the stream with the error.
 
@@ -405,12 +455,12 @@ The **MQTT+** API provides the following methods:
       /*  (simplified TypeScript API method signature)  */
       push(
           resource:       string,
-          streamOrBuffer: Readable | Buffer,
+          streamOrBuffer: Readable | Uint8Array,
           ...params:      any[]
       ): Promise<void>
       push({
           resource:       string,
-          streamOrBuffer: Readable | Buffer,
+          streamOrBuffer: Readable | Uint8Array,
           params:         any[]
           meta?:          Record<string, any>,
           receiver?:      string,
@@ -418,7 +468,7 @@ The **MQTT+** API provides the following methods:
       }): Promise<void>
 
   Pushes a resource to all provisioners or a specific provisioner.
-  The `streamOrBuffer` is either a Node.js `Readable` stream or a `Buffer` providing the data to push.
+  The `streamOrBuffer` is either a Node.js `Readable` stream or a `Uint8Array` providing the data to push.
   The optional `meta` sends metadata alongside the resource data,
   which becomes available on the provisioner side via `info.meta`.
   The optional `receiver` directs the push to a specific provisioner only.
@@ -431,7 +481,7 @@ The **MQTT+** API provides the following methods:
 
   The remote `provision()` `callback` is called with `params` and an `info` object
   containing `stream` (`Readable`) for consuming the pushed data,
-  `buffer` (lazy `Promise<Buffer>`) that resolves to the complete data once the stream ends,
+  `buffer` (lazy `Promise<Uint8Array>`) that resolves to the complete data once the stream ends,
   and `meta` (`Record<string, any> | undefined`) containing the metadata sent by the pusher.
 
   Internally, publishes to the MQTT topic by `topicMake(resource, "resource-transfer-response", peerId)`
@@ -446,8 +496,12 @@ In the following, we assume that an **MQTT+** instance is created with:
 import MQTT  from "mqtt"
 import MQTTp from "mqtt-plus"
 
+export type API = {
+    "example/sample": Event<(a1: string, a2: number) => void>
+    ...
+}
 const mqtt  = MQTT.connect("...", { ... })
-const mqttp = new MQTTp(mqtt, { codec: "json" })
+const mqttp = new MQTTp<API>(mqtt, { codec: "json" })
 ```
 
 Internally, remote services are assigned to MQTT topics. When calling a
@@ -501,78 +555,18 @@ The `sender` field is the NanoID of the MQTT+ sender instance and
 used for sending back the response message to the requestor only. The
 `id` is used for correlating the response to the request only.
 
-Broker Setup
-------------
-
-For a real test-drive of MQTT+, install the
-[Mosquitto](https://mosquitto.org/) MQTT broker and a `mosquitto.conf`
-file like...
-
-```
-[...]
-
-password_file        mosquitto-pwd.txt
-acl_file             mosquitto-acl.txt
-
-[...]
-
-#   additional listener
-listener             1883 127.0.0.1
-max_connections      -1
-protocol             mqtt
-
-[...]
-```
-
-...and an access control list in `mosquitto-acl.txt` like...
-
-```
-#   shared ACL
-topic   read      $SYS/#
-pattern write     $SYS/broker/connection/%c/state
-pattern readwrite %u/#
-
-#   anonymous ACL
-topic   read      event/+
-pattern read      event/+/%c
-topic   write     event/+/+
-pattern read      service/+/%c
-topic   write     service/+
-topic   write     service/+/+
-
-#   user ACL
-user    example
-topic   read      event/+
-pattern read      event/+/%c
-topic   write     event/+
-topic   write     event/+/+
-topic   read      service/+
-pattern read      service/+/%c
-topic   write     service/+
-topic   write     service/+/+
-```
-
-...and an `example` user (with password `example`) in `mosquitto-pwd.txt` like:
-
-```
-example:$6$awYNe6oCAi+xlvo5$mWIUqyy4I0O3nJ99lP1mkRVqsDGymF8en5NChQQxf7KrVJLUp1SzrrVDe94wWWJa3JGIbOXD9wfFGZdi948e6A==
-```
-
-Alternatively, you can use the [NPM package mosquitto](https://npmjs.com/mosquitto)
-for an equal setup.
-
 Example
 -------
 
-You can test-drive MQTT+ with a complete [sample](sample/sample.ts) to see
-it in action and tracing its communication (the typing of the `MQTTp`
-class with `API` is optional, but strongly suggested):
+You can test-drive MQTT+, in a temporary MQTT broker environment,
+with a complete [sample](sample/sample.ts) to see it in action and
+tracing its communication:
 
 ```ts
-import Mosquitto        from "mosquitto"
-import MQTT             from "mqtt"
-import MQTTp            from "mqtt-plus"
-import type * as MQTTpt from "mqtt-plus"
+import Mosquitto                         from "mosquitto"
+import MQTT                              from "mqtt"
+import MQTTp                             from "mqtt-plus"
+import type { Event, Service, Resource } from "mqtt-plus"
 
 const mosquitto = new Mosquitto()
 await mosquitto.start()
@@ -584,9 +578,9 @@ const mqtt = MQTT.connect("mqtt://127.0.0.1:1883", {
 })
 
 type API = {
-    "example/sample":   MQTTpt.Event<(a1: string, a2: number) => void>
-    "example/hello":    MQTTpt.Service<(a1: string, a2: number) => string>
-    "example/resource": MQTTpt.Resource<(filename: string) => void>
+    "example/sample":   Event<(a1: string, a2: number) => void>
+    "example/hello":    Service<(a1: string, a2: number) => string>
+    "example/resource": Resource<(filename: string) => void>
 }
 
 const mqttp = new MQTTp<API>(mqtt, { codec: "json" })
@@ -620,11 +614,12 @@ mqtt.on("connect", async () => {
     /*  resource fetch example  */
     const prov = await mqttp.provision("example/resource", async (filename, info) => {
         console.log("example/resource: request:", filename, "from:", info.sender)
-        info.buffer = Promise.resolve(Buffer.from(`the ${filename} content`))
+        const data = `the ${filename} content`
+        info.buffer = Promise.resolve(new TextEncoder().encode(data))
     })
     const res = await mqttp.fetch("example/resource", "foo")
-    const data = await res.buffer
-    console.log("example/resource: result:", data.toString())
+    const data = new TextDecoder().decode(await res.buffer)
+    console.log("example/resource: result:", data)
     await prov.unprovision()
 
     mqtt.end()
@@ -650,11 +645,68 @@ example/resource: result: the foo content
 CLOSE
 ```
 
+Broker Setup
+------------
+
+For establishing your own permanent MQTT environment, install the
+[Mosquitto](https://mosquitto.org/) MQTT broker yourself and a setup
+a `mosquitto.conf` file like...
+
+```
+[...]
+
+password_file        mosquitto-pwd.txt
+acl_file             mosquitto-acl.txt
+
+[...]
+
+#   additional listener
+listener             1883 127.0.0.1
+max_connections      -1
+protocol             mqtt
+
+[...]
+```
+
+...and an access control list in `mosquitto-acl.txt` like...
+
+```
+#   shared ACL
+topic   read      $SYS/#
+pattern write     $SYS/broker/connection/%c/state
+pattern readwrite %u/#
+
+#   anonymous ACL
+topic   read      event/+
+pattern read      event/+/%c
+topic   write     event/+/+
+pattern read      service/+/%c
+topic   write     service/+
+topic   write     service/+/+
+
+#   user ACL
+user    example
+topic   read      event/+
+pattern read      event/+/%c
+topic   write     event/+
+topic   write     event/+/+
+topic   read      service/+
+pattern read      service/+/%c
+topic   write     service/+
+topic   write     service/+/+
+```
+
+...and an `example` user (with password `example`) in `mosquitto-pwd.txt` like:
+
+```
+example:$6$awYNe6oCAi+xlvo5$mWIUqyy4I0O3nJ99lP1mkRVqsDGymF8en5NChQQxf7KrVJLUp1SzrrVDe94wWWJa3JGIbOXD9wfFGZdi948e6A==
+```
+
 Notice
 ------
 
 > [!Note]
-> **MQTT+** is somewhat similar to and originally derived from
+> **MQTT+** is somewhat similar to and originally derived from the weaker
 > [MQTT-JSON-RPC](https://github.com/rse/mqtt-json-rpc) of the same
 > author, but instead of just JSON, MQTT+ encodes packets as JSON
 > or CBOR (default), uses an own packet format (allowing sender and

package/dst-stage1/mqtt-plus-base.js

@@ -35,7 +35,7 @@ export class BaseTrait extends MsgTrait {
                     if (prop === "isFakeProxy")
                         return true;
                     else
-                        return (...args) => { };
+                        return () => { };
                 }
             });
         /*  store MQTT client  */

package/dst-stage1/mqtt-plus-codec.js

@@ -86,9 +86,7 @@ export default class Codec {
     }
     decode(data) {
         let result;
-        if (this.type === "cbor"
-            && typeof data === "object"
-            && data instanceof Uint8Array) {
+        if (this.type === "cbor" && data instanceof Uint8Array) {
             try {
                 result = CBOR.decode(data, { tags: this.tags });
             }

package/dst-stage1/mqtt-plus-event.d.ts

@@ -9,7 +9,12 @@ export interface Subscription {
 export declare class EventTrait<T extends APISchema = APISchema> extends BaseTrait<T> {
     private subscriptions;
     subscribe<K extends EventKeys<T> & string>(event: K, callback: WithInfo<T[K], InfoEvent>): Promise<Subscription>;
-    subscribe<K extends EventKeys<T> & string>(event: K, options: Partial<IClientSubscribeOptions>, callback: WithInfo<T[K], InfoEvent>): Promise<Subscription>;
+    subscribe<K extends EventKeys<T> & string>(config: {
+        event: K;
+        callback: WithInfo<T[K], InfoEvent>;
+        options?: Partial<IClientSubscribeOptions>;
+        share?: string;
+    }): Promise<Subscription>;
     emit<K extends EventKeys<T> & string>(event: K, ...params: Parameters<T[K]>): void;
     emit<K extends EventKeys<T> & string>(config: {
         event: K;

package/dst-stage1/mqtt-plus-event.js

@@ -34,20 +34,31 @@ export class EventTrait extends BaseTrait {
         /*  internal state  */
         this.subscriptions = new Map();
     }
-    async subscribe(event, ...args) {
-        /*  determine parameters  */
+    async subscribe(eventOrConfig, ...args) {
+        /*  determine actual parameters  */
+        let event;
+        let callback;
         let options = {};
-        let callback = args[0];
-        if (args.length === 2 && typeof args[0] === "object") {
-            options = args[0];
-            callback = args[1];
+        let share;
+        if (typeof eventOrConfig === "object" && eventOrConfig !== null) {
+            /*  object-based API  */
+            event = eventOrConfig.event;
+            callback = eventOrConfig.callback;
+            options = eventOrConfig.options ?? {};
+            share = eventOrConfig.share;
+        }
+        else {
+            /*  positional API  */
+            event = eventOrConfig;
+            callback = args[0];
         }
         /*  sanity check situation  */
         if (this.subscriptions.has(event))
             throw new Error(`subscribe: event "${event}" already subscribed`);
         /*  generate the corresponding MQTT topics for broadcast and direct use  */
-        const topicB = this.options.topicMake(event, "event-emission");
-        const topicD = this.options.topicMake(event, "event-emission", this.options.id);
+        const name = share ? `$share/${share}/${event}` : event;
+        const topicB = this.options.topicMake(name, "event-emission");
+        const topicD = this.options.topicMake(name, "event-emission", this.options.id);
         /*  subscribe to MQTT topics  */
         await Promise.all([
             this._subscribeTopic(topicB, { qos: 0, ...options }),

package/dst-stage1/mqtt-plus-msg.d.ts

@@ -1,11 +1,12 @@
 import { APISchema } from "./mqtt-plus-api";
 import { CodecTrait } from "./mqtt-plus-codec";
+type MessageType = "event-emission" | "service-call-request" | "service-call-response" | "resource-transfer-request" | "resource-transfer-response";
 declare class Base {
-    type: string;
+    type: MessageType;
     id: string;
     sender?: string | undefined;
     receiver?: string | undefined;
-    constructor(type: string, id: string, sender?: string | undefined, receiver?: string | undefined);
+    constructor(type: MessageType, id: string, sender?: string | undefined, receiver?: string | undefined);
 }
 export declare class EventEmission extends Base {
     event: string;

package/dst-stage1/mqtt-plus-msg.js

@@ -153,7 +153,7 @@ class Msg {
         else if (obj.type === "resource-transfer-response") {
             if (obj.resource !== undefined && typeof obj.resource !== "string")
                 throw new Error("invalid ResourceTransferResponse object: \"resource\" field must be a string");
-            if (obj.chunk !== undefined && typeof obj.chunk !== "object")
+            if (obj.chunk !== undefined && (obj.chunk === null || typeof obj.chunk !== "object"))
                 throw new Error("invalid ResourceTransferResponse object: \"chunk\" field must be an object");
             if (obj.meta !== undefined && (typeof obj.meta !== "object" || obj.meta === null || Array.isArray(obj.meta)))
                 throw new Error("invalid ResourceTransferResponse object: \"meta\" field must be an object");

package/dst-stage1/mqtt-plus-resource.d.ts

@@ -12,7 +12,12 @@ export declare class ResourceTrait<T extends APISchema = APISchema> extends Serv
     private pushStreams;
     private pushTimers;
     provision<K extends ResourceKeys<T> & string>(resource: K, callback: WithInfo<T[K], InfoResource>): Promise<Provisioning>;
-    provision<K extends ResourceKeys<T> & string>(resource: K, options: Partial<IClientSubscribeOptions>, callback: WithInfo<T[K], InfoResource>): Promise<Provisioning>;
+    provision<K extends ResourceKeys<T> & string>(config: {
+        resource: K;
+        callback: WithInfo<T[K], InfoResource>;
+        options?: Partial<IClientSubscribeOptions>;
+        share?: string;
+    }): Promise<Provisioning>;
     push<K extends ResourceKeys<T> & string>(resource: K, data: Readable | Uint8Array, ...params: Parameters<T[K]>): Promise<void>;
     push<K extends ResourceKeys<T> & string>(config: {
         resource: K;