mqtt-plus 0.9.11 → 0.9.13

package/README.md

@@ -87,12 +87,12 @@ The API type defines the available endpoints. Use the marker types
 pattern of each endpoint:
 
 ```ts
-import type * as MQTTpt from "mqtt-plus"
+import type { Event, Service, Resource } from "mqtt-plus"
 
 export 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>
 }
 ```
 
@@ -108,7 +108,7 @@ import MQTT         from "mqtt"
 import MQTTp        from "mqtt-plus"
 import type { API } from [...]
 
-const mqtt  = MQTT.connect("wss://127.0.0.1:8883", { ... })
+const mqtt  = MQTT.connect("wss://127.0.0.1:8883", { [...] })
 const mqttp = new MQTTp<API>(mqtt)
 
 mqtt.on("connect", async () => {
@@ -129,7 +129,7 @@ import MQTT         from "mqtt"
 import MQTTp        from "mqtt-plus"
 import type { API } from [...]
 
-const mqtt = MQTT.connect("wss://127.0.0.1:8883", { ... })
+const mqtt = MQTT.connect("wss://127.0.0.1:8883", { [...] })
 const mqttp = new MQTTp<API>(mqtt)
 
 mqtt.on("connect", () => {
@@ -179,7 +179,8 @@ The **MQTT+** API provides the following methods:
     The `operation` parameter is one of: `event-emission`, `service-call-request`, `service-call-response`, `resource-transfer-request`, `resource-transfer-response`.
     (default: `` (name, operation, peerId) => `${name}/${protocol}/${peerId ?? "any"}` ``)
   - `topicMatch`: Custom topic matching function.
-    Returns `{ name, operation, peerId? }` or `null` if no match. The `peerId` is `undefined` for broadcast topics (ending with `/any`).
+    Returns `{ name, operation, peerId? }` or `null` if no match.
+    The `peerId` is `undefined` for broadcast topics (ending with `/any`).
     (default: `` (topic) => { const m = topic.match(/^(.+)\/([^/]+)\/([^/]+)$/); return m ? { name: m[1], operation: m[2], peerId: m[3] === "any" ? undefined : m[3] } : null } ``)
 
 - **Destruction**:<br/>
@@ -246,7 +247,6 @@ The **MQTT+** API provides the following methods:
               info: {
                   sender: string,
                   receiver?: string,
-                  resource: Buffer | Readable | null,
                   meta?: Record<string, any>,
                   stream?: Readable,
                   buffer?: Promise<Buffer>
@@ -259,7 +259,7 @@ The **MQTT+** API provides the following methods:
   The optional `options` allows setting MQTT.js `subscribe()` options like `qos`.
 
   For **fetch requests**: The `callback` is called with the `params` passed to a remote `fetch()`.
-  The `callback` should set `info.resource` to a `Buffer` or `Readable` containing the resource data.
+  The `callback` should set `info.stream` to a `Readable` or `info.buffer` to a `Promise<Buffer>` 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()`.
@@ -278,10 +278,14 @@ The **MQTT+** API provides the following methods:
       /*  (simplified TypeScript API method signature)  */
       emit(
           event:     string,
-          receiver?: Receiver,
-          options?:  MQTT::IClientSubscribeOptions,
           ...params: any[]
       ): void
+      emit({
+          event:     string,
+          params:    any[],
+          receiver?: string,
+          options?:  MQTT::IClientSubscribeOptions
+      }): void
 
   Emit an event to all subscribers or a specific subscriber ("fire and forget").
   The optional `receiver` directs the event to a specific subscriber only.
@@ -298,10 +302,14 @@ The **MQTT+** API provides the following methods:
       /*  (simplified TypeScript API method signature)  */
       call(
           service:   string,
-          receiver?: Receiver,
-          options?:  MQTT::IClientSubscribeOptions,
           ...params: any[]
       ): Promise<any>
+      call({
+          service:   string,
+          params:    any[],
+          receiver?: string,
+          options?:  MQTT::IClientPublishOptions
+      }): Promise<any>
 
   Call a service on all registrants or on a specific registrant ("request and response").
   The optional `receiver` directs the call to a specific registrant only.
@@ -320,10 +328,22 @@ The **MQTT+** API provides the following methods:
       /*  (simplified TypeScript API method signature)  */
       fetch(
           resource:  string,
-          receiver?: Receiver,
-          options?:  MQTT::IClientSubscribeOptions,
           ...params: any[]
-      ): Promise<{ stream: Readable, buffer: Promise<Buffer>, meta: Promise<Record<string, any> | undefined> }>
+      ): Promise<{
+          stream:    Readable,
+          buffer:    Promise<Buffer>,
+          meta:      Promise<Record<string, any> | undefined>
+      }>
+      fetch({
+          resource:  string,
+          params:    any[],
+          receiver?: string,
+          options?:  MQTT::IClientSubscribeOptions
+      }): Promise<{
+          stream:    Readable,
+          buffer:    Promise<Buffer>,
+          meta:      Promise<Record<string, any> | undefined>
+      }>
 
   Fetches a resource from any resource provisioner or from a specific provisioner.
   The optional `receiver` directs the call to a specific provisioner only.
@@ -335,7 +355,7 @@ The **MQTT+** API provides the following methods:
   sent by the provisioner when the first chunk arrives.
 
   The remote `provision()` `callback` is called with `params` and
-  should set `info.resource` to a `Buffer` or `Readable` containing the resource data.
+  should set `info.stream` to a `Readable` or `info.buffer` to a `Promise<Buffer>` 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.
 
@@ -350,15 +370,20 @@ The **MQTT+** API provides the following methods:
       push(
           resource:       string,
           streamOrBuffer: Readable | Buffer,
-          meta?:          Meta,
-          receiver?:      Receiver,
-          options?:       MQTT::IClientPublishOptions,
           ...params:      any[]
       ): Promise<void>
+      push({
+          resource:       string,
+          streamOrBuffer: Readable | Buffer,
+          params:         any[]
+          meta?:          Record<string, any>,
+          receiver?:      string,
+          options?:       MQTT::IClientPublishOptions
+      }): 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 optional `meta` (wrapped via `meta()`) sends metadata alongside the resource data,
+  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.
   The optional `options` allows setting MQTT.js `publish()` options like `qos` or `retain`.
@@ -376,25 +401,6 @@ The **MQTT+** API provides the following methods:
   Internally, publishes to the MQTT topic by `topicMake(resource, "resource-transfer-response", peerId)`
   (default: `${resource}/resource-transfer-response/any` or `${resource}/resource-transfer-response/${peerId}`).
 
-- **Receiver Wrapping**:<br/>
-
-      receiver(
-          id: string
-      ): Receiver
-
-  Wrap a receiver ID string for use with `emit()`, `call()`, `fetch()` or `push()` to direct the
-  message to a specific receiver. Returns a `Receiver` object.
-
-- **Meta Wrapping**:<br/>
-
-      meta(
-          data: Record<string, any>
-      ): Meta
-
-  Wrap a metadata object for use with `push()` to send metadata alongside the resource data.
-  The metadata is transferred with the first chunk and becomes available on the provisioner
-  side via `info.meta`. Returns a `Meta` object.
-
 Internals
 ---------
 
@@ -542,14 +548,13 @@ 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/sample":   MQTTpt.Event<(a1: string, a2: number) => void>
+    "example/hello":    MQTTpt.Service<(a1: string, a2: number) => string>
+    "example/resource": MQTTpt.Resource<(filename: string) => void>
 }
 
 const mqttp = new MQTTp<API>(mqtt, { codec: "json" })
 
-type Sample = (a: string, b: number) => string
-
 mqtt.on("error",     (err)            => { console.log("ERROR", err) })
 mqtt.on("offline",   ()               => { console.log("OFFLINE") })
 mqtt.on("close",     ()               => { console.log("CLOSE") })
@@ -558,17 +563,36 @@ mqtt.on("message",   (topic, message) => { console.log("RECEIVED", topic, messag
 
 mqtt.on("connect", async () => {
     console.log("CONNECT")
-    await mqttp.register("example/hello", (a1, a2, info) => {
+
+    /*  event emission example  */
+    const sub = await mqttp.subscribe("example/sample", (a1, a2, info) => {
+        console.log("example/sample: received:", a1, a2, "from:", info.sender)
+    })
+    mqttp.emit("example/sample", "world", 42)
+    await new Promise((resolve) => { setTimeout(resolve, 100) })
+    await sub.unsubscribe()
+
+    /*  service call example  */
+    const reg = await mqttp.register("example/hello", (a1, a2, info) => {
         console.log("example/hello: request:", a1, a2, "from:", info.sender)
         return `${a1}:${a2}`
     })
-    mqttp.call("example/hello", "world", 42).then(async (result) => {
-        console.log("example/hello success:", result)
-        mqtt.end()
-        await mosquitto.stop()
-    }).catch((err) => {
-        console.log("example/hello error:", err)
+    const result = await mqttp.call("example/hello", "world", 42)
+    console.log("example/hello: success:", result)
+    await reg.unregister()
+
+    /*  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 res = await mqttp.fetch("example/resource", "foo")
+    const data = await res.buffer
+    console.log("example/resource: result:", data.toString())
+    await prov.unprovision()
+
+    mqtt.end()
+    await mosquitto.stop()
 })
 ```
 
@@ -577,10 +601,16 @@ The output will be:
 ```
 $ node sample.ts
 CONNECT
-RECEIVED example/hello/service-call-request/any {"type":"service-call-request","id":"vwLzfQDu2uEeOdOfIlT42","sender":"2IBMSk0NPnrz1AeTERoea","service":"example/hello","params":["world",42]}
-example/hello: request: world 42 from: 2IBMSk0NPnrz1AeTERoea
-RECEIVED example/hello/service-call-response/2IBMSk0NPnrz1AeTERoea {"type":"service-call-response","id":"vwLzfQDu2uEeOdOfIlT42","sender":"2IBMSk0NPnrz1AeTERoea","receiver":"2IBMSk0NPnrz1AeTERoea","result":"world:42"}
-example/hello success: world:42
+RECEIVED example/sample/event-emission/any {"type":"event-emission","id":"...","sender":"...","event":"example/sample","params":["world",42]}
+example/sample: received: world 42 from: ...
+RECEIVED example/hello/service-call-request/any {"type":"service-call-request","id":"...","sender":"...","service":"example/hello","params":["world",42]}
+example/hello: request: world 42 from: ...
+RECEIVED example/hello/service-call-response/... {"type":"service-call-response","id":"...","sender":"...","receiver":"...","result":"world:42"}
+example/hello: success: world:42
+RECEIVED example/resource/resource-transfer-request/any {"type":"resource-transfer-request","id":"...","sender":"...","resource":"example/resource","params":["foo"]}
+example/resource: request: foo from: ...
+RECEIVED example/resource/resource-transfer-response/... {"type":"resource-transfer-response","id":"...","sender":"...","receiver":"...","chunk":...,"final":true}
+example/resource: result: the foo content
 CLOSE
 ```
 

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

@@ -1,21 +1,14 @@
-import { MqttClient, IClientPublishOptions, IClientSubscribeOptions } from "mqtt";
+import { MqttClient, IClientSubscribeOptions } from "mqtt";
 import { APISchema } from "./mqtt-plus-api";
+import { MsgTrait } from "./mqtt-plus-msg";
 import { APIOptions } from "./mqtt-plus-options";
-import { MetaTrait } from "./mqtt-plus-meta";
-export declare class BaseTrait<T extends APISchema = APISchema> extends MetaTrait<T> {
+export declare class BaseTrait<T extends APISchema = APISchema> extends MsgTrait<T> {
     protected mqtt: MqttClient;
     private _messageHandler;
     constructor(mqtt: MqttClient, options?: Partial<APIOptions>);
     destroy(): void;
     protected _subscribeTopic(topic: string, options?: Partial<IClientSubscribeOptions>): Promise<void>;
     protected _unsubscribeTopic(topic: string): Promise<void>;
-    private _isIClientPublishOptions;
-    protected _parseCallArgs<U extends any[]>(args: any[]): {
-        meta?: Record<string, any>;
-        receiver?: string;
-        options: IClientPublishOptions;
-        params: U;
-    };
     private _onMessage;
     protected _dispatchMessage(_topic: string, _parsed: any): void;
 }

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

@@ -21,9 +21,9 @@
 **  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 **  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
-import { MetaTrait } from "./mqtt-plus-meta";
+import { MsgTrait } from "./mqtt-plus-msg";
 /*  MQTTp Base class with shared infrastructure  */
-export class BaseTrait extends MetaTrait {
+export class BaseTrait extends MsgTrait {
     /*  construct API class  */
     constructor(mqtt, options = {}) {
         super(options);
@@ -61,38 +61,6 @@ export class BaseTrait extends MetaTrait {
             });
         });
     }
-    /*  check whether argument has structure of interface IClientPublishOptions  */
-    _isIClientPublishOptions(arg) {
-        if (typeof arg !== "object")
-            return false;
-        const keys = ["qos", "retain", "dup", "properties", "cbStorePut"];
-        return Object.keys(arg).every((key) => keys.includes(key));
-    }
-    /*  parse optional meta, receiver and options from variadic arguments  */
-    _parseCallArgs(args) {
-        /*  extract optional meta from arguments  */
-        let meta;
-        if (args.length > 0 && this._isMeta(args[0]))
-            meta = this._getMeta(args.shift());
-        /*  extract optional receiver and options from arguments  */
-        let receiver;
-        let options = {};
-        let params = args;
-        if (args.length >= 2 && this._isReceiver(args[0]) && this._isIClientPublishOptions(args[1])) {
-            receiver = this._getReceiver(args[0]);
-            options = args[1];
-            params = args.slice(2);
-        }
-        else if (args.length >= 1 && this._isReceiver(args[0])) {
-            receiver = this._getReceiver(args[0]);
-            params = args.slice(1);
-        }
-        else if (args.length >= 1 && this._isIClientPublishOptions(args[0])) {
-            options = args[0];
-            params = args.slice(1);
-        }
-        return { meta, receiver, options, params };
-    }
     /*  handle incoming MQTT message  */
     _onMessage(topic, message, packet) {
         /*  try to parse message as payload  */

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

@@ -22,8 +22,19 @@
 **  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 /*  external requirements  */
-import CBOR from "cbor";
+import * as CBOR from "cbor2";
+import { registerEncoder } from "cbor2/encoder";
+import { Tag } from "cbor2/tag";
 import { OptionsTrait } from "./mqtt-plus-options";
+/*  directly support Buffer type for CBOR  */
+registerEncoder(Buffer, (buffer) => [
+    64000,
+    new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+]);
+Tag.registerDecoder(64000, (tag) => {
+    const array = tag.contents;
+    return Buffer.copyBytesFrom(array);
+});
 /*  the encoder/decoder abstraction  */
 export default class Codec {
     constructor(type) {
@@ -33,7 +44,7 @@ export default class Codec {
         let result;
         if (this.type === "cbor") {
             try {
-                result = CBOR.encode(data);
+                result = Buffer.from(CBOR.encode(data));
             }
             catch (_ex) {
                 throw new Error("failed to encode CBOR format");

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

@@ -1,7 +1,6 @@
 import { IClientPublishOptions, IClientSubscribeOptions } from "mqtt";
 import { APISchema, EventKeys } from "./mqtt-plus-api";
 import type { WithInfo, InfoEvent } from "./mqtt-plus-info";
-import type { Receiver } from "./mqtt-plus-receiver";
 import { BaseTrait } from "./mqtt-plus-base";
 export interface Subscription {
     unsubscribe(): Promise<void>;
@@ -11,8 +10,11 @@ export declare class EventTrait<T extends APISchema = APISchema> extends BaseTra
     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>;
     emit<K extends EventKeys<T> & string>(event: K, ...params: Parameters<T[K]>): void;
-    emit<K extends EventKeys<T> & string>(event: K, receiver: Receiver, ...params: Parameters<T[K]>): void;
-    emit<K extends EventKeys<T> & string>(event: K, options: IClientPublishOptions, ...params: Parameters<T[K]>): void;
-    emit<K extends EventKeys<T> & string>(event: K, receiver: Receiver, options: IClientPublishOptions, ...params: Parameters<T[K]>): void;
+    emit<K extends EventKeys<T> & string>(config: {
+        event: K;
+        params: Parameters<T[K]>;
+        receiver?: string;
+        options?: IClientPublishOptions;
+    }): void;
     protected _dispatchMessage(topic: string, parsed: any): void;
 }

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

@@ -72,9 +72,24 @@ export class EventTrait extends BaseTrait {
         };
         return subscription;
     }
-    emit(event, ...args) {
+    emit(eventOrConfig, ...args) {
         /*  determine actual parameters  */
-        const { receiver, options, params } = this._parseCallArgs(args);
+        let event;
+        let params;
+        let receiver;
+        let options = {};
+        if (typeof eventOrConfig === "object" && eventOrConfig !== null) {
+            /*  object-based API  */
+            event = eventOrConfig.event;
+            params = eventOrConfig.params;
+            receiver = eventOrConfig.receiver;
+            options = eventOrConfig.options ?? {};
+        }
+        else {
+            /*  positional API  */
+            event = eventOrConfig;
+            params = args;
+        }
         /*  generate unique request id  */
         const rid = nanoid();
         /*  generate encoded message  */

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

@@ -8,7 +8,6 @@ export interface InfoEvent extends InfoBase {
 export interface InfoService extends InfoBase {
 }
 export interface InfoResource extends InfoBase {
-    resource: Buffer | Readable | null;
     meta?: Record<string, any>;
     stream?: Readable;
     buffer?: Promise<Buffer>;

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

@@ -1,9 +1,9 @@
 import { APISchema } from "./mqtt-plus-api";
-import { ReceiverTrait } from "./mqtt-plus-receiver";
+import { MsgTrait } from "./mqtt-plus-msg";
 export type Meta = {
     __meta: Record<string, any>;
 };
-export declare class MetaTrait<T extends APISchema = APISchema> extends ReceiverTrait<T> {
+export declare class MetaTrait<T extends APISchema = APISchema> extends MsgTrait<T> {
     meta(data: Record<string, any>): {
         __meta: Record<string, any>;
     };

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

@@ -21,9 +21,9 @@
 **  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 **  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
-import { ReceiverTrait } from "./mqtt-plus-receiver";
+import { MsgTrait } from "./mqtt-plus-msg";
 /*  Meta trait  */
-export class MetaTrait extends ReceiverTrait {
+export class MetaTrait extends MsgTrait {
     /*  wrap meta object into wrapper (required for type-safe overloading)  */
     meta(data) {
         return { __meta: data };

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

@@ -1,6 +1,6 @@
 import { APISchema } from "./mqtt-plus-api";
 import { CodecTrait } from "./mqtt-plus-codec";
-export declare class Base {
+declare class Base {
     type: string;
     id: string;
     sender?: string | undefined;
@@ -36,7 +36,7 @@ export declare class ResourceTransferResponse extends Base {
     final?: boolean | undefined;
     constructor(id: string, resource?: string | undefined, params?: any[] | undefined, chunk?: Buffer | undefined, meta?: Record<string, any> | undefined, error?: string | undefined, final?: boolean | undefined, sender?: string, receiver?: string);
 }
-export default class Msg {
+declare class Msg {
     makeEventEmission(id: string, event: string, params?: any[], sender?: string, receiver?: string): EventEmission;
     makeServiceCallRequest(id: string, service: string, params?: any[], sender?: string, receiver?: string): ServiceCallRequest;
     makeServiceCallResponse(id: string, result?: any, error?: string, sender?: string, receiver?: string): ServiceCallResponse;
@@ -47,3 +47,4 @@ export default class Msg {
 export declare class MsgTrait<T extends APISchema = APISchema> extends CodecTrait<T> {
     protected msg: Msg;
 }
+export {};

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

@@ -23,7 +23,7 @@
 */
 import { CodecTrait } from "./mqtt-plus-codec";
 /*  base class  */
-export class Base {
+class Base {
     constructor(type, id, sender, receiver) {
         this.type = type;
         this.id = id;
@@ -76,7 +76,7 @@ export class ResourceTransferResponse extends Base {
     }
 }
 /*  utility class  */
-export default class Msg {
+class Msg {
     /*  factory for event emission  */
     makeEventEmission(id, event, params, sender, receiver) {
         return new EventEmission(id, event, params, sender, receiver);
@@ -110,9 +110,10 @@ export default class Msg {
             throw new Error("invalid object: invalid \"sender\" field");
         if ("receiver" in obj && obj.receiver !== undefined && typeof obj.receiver !== "string")
             throw new Error("invalid object: invalid \"receiver\" field");
-        /*  dispatch according to type indication by field  */
+        /*  utility predicates for validation  */
         const anyFieldsExcept = (obj, allowed) => Object.keys(obj).some((key) => !allowed.includes(key));
         const validParams = (obj) => obj.params === undefined || (typeof obj.params === "object" && Array.isArray(obj.params));
+        /*  dispatch according to type indication by field  */
         if (obj.type === "event-emission") {
             /*  detect and parse event emission  */
             if (typeof obj.event !== "string")

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

@@ -1,11 +1,11 @@
 import { APISchema } from "./mqtt-plus-api";
-export type TopicMake = (name: string, operation: string, peerId?: string) => string;
-export type TopicMatch = (topic: string) => TopicMatching | null;
-export type TopicMatching = {
+type TopicMatching = {
     name: string;
     operation: string;
     peerId?: string;
 };
+export type TopicMake = (name: string, operation: string, peerId?: string) => string;
+export type TopicMatch = (topic: string) => TopicMatching | null;
 export interface APIOptions {
     id: string;
     codec: "cbor" | "json";
@@ -18,3 +18,4 @@ export declare class OptionsTrait<T extends APISchema = APISchema> {
     protected options: APIOptions;
     constructor(options?: Partial<APIOptions>);
 }
+export {};

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

@@ -2,8 +2,6 @@ import { Readable } from "stream";
 import { IClientPublishOptions, IClientSubscribeOptions } from "mqtt";
 import { APISchema, ResourceKeys } from "./mqtt-plus-api";
 import type { WithInfo, InfoResource } from "./mqtt-plus-info";
-import type { Receiver } from "./mqtt-plus-receiver";
-import type { Meta } from "./mqtt-plus-meta";
 import { ServiceTrait } from "./mqtt-plus-service";
 export interface Provisioning {
     unprovision(): Promise<void>;
@@ -15,38 +13,26 @@ export declare class ResourceTrait<T extends APISchema = APISchema> extends Serv
     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>;
-    push<K extends ResourceKeys<T> & string>(resource: K, stream: Readable, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, stream: Readable, receiver: Receiver, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, stream: Readable, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, stream: Readable, receiver: Receiver, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, buffer: Buffer, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, buffer: Buffer, receiver: Receiver, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, buffer: Buffer, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, buffer: Buffer, receiver: Receiver, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, buffer: Buffer, meta: Meta, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, buffer: Buffer, meta: Meta, receiver: Receiver, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, buffer: Buffer, meta: Meta, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, buffer: Buffer, meta: Meta, receiver: Receiver, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, stream: Readable, meta: Meta, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, stream: Readable, meta: Meta, receiver: Receiver, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, stream: Readable, meta: Meta, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<void>;
-    push<K extends ResourceKeys<T> & string>(resource: K, stream: Readable, meta: Meta, receiver: Receiver, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<void>;
+    push<K extends ResourceKeys<T> & string>(resource: K, data: Readable | Buffer, ...params: Parameters<T[K]>): Promise<void>;
+    push<K extends ResourceKeys<T> & string>(config: {
+        resource: K;
+        data: Readable | Buffer;
+        params: Parameters<T[K]>;
+        meta?: Record<string, any>;
+        receiver?: string;
+        options?: IClientPublishOptions;
+    }): Promise<void>;
     fetch<K extends ResourceKeys<T> & string>(resource: K, ...params: Parameters<T[K]>): Promise<{
         stream: Readable;
         buffer: Promise<Buffer>;
         meta: Promise<Record<string, any> | undefined>;
     }>;
-    fetch<K extends ResourceKeys<T> & string>(resource: K, receiver: Receiver, ...params: Parameters<T[K]>): Promise<{
-        stream: Readable;
-        buffer: Promise<Buffer>;
-        meta: Promise<Record<string, any> | undefined>;
-    }>;
-    fetch<K extends ResourceKeys<T> & string>(resource: K, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<{
-        stream: Readable;
-        buffer: Promise<Buffer>;
-        meta: Promise<Record<string, any> | undefined>;
-    }>;
-    fetch<K extends ResourceKeys<T> & string>(resource: K, receiver: Receiver, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<{
+    fetch<K extends ResourceKeys<T> & string>(config: {
+        resource: K;
+        params: Parameters<T[K]>;
+        receiver?: string;
+        options?: IClientPublishOptions;
+    }): Promise<{
         stream: Readable;
         buffer: Promise<Buffer>;
         meta: Promise<Record<string, any> | undefined>;