@bitwarden/sdk-internal 0.2.0-main.135 → 0.2.0-main.137

package/VERSION

@@ -1 +1 @@
-8f4e5211f80181b2adbb5a1af12625c53e03a0ba
+f28b4efe48db42b43f2358fa9d96d0c663450abd

package/bitwarden_wasm_internal.d.ts

@@ -295,17 +295,6 @@ export type Endpoint =
   | "DesktopRenderer"
   | "DesktopMain";
 
-export interface OutgoingMessage {
-  data: number[];
-  destination: Endpoint;
-}
-
-export interface IncomingMessage {
-  data: number[];
-  destination: Endpoint;
-  source: Endpoint;
-}
-
 export interface CommunicationBackend {
   send(message: OutgoingMessage): Promise<void>;
   receive(): Promise<IncomingMessage>;
@@ -894,12 +883,42 @@ export class CryptoClient {
    */
   verify_asymmetric_keys(request: VerifyAsymmetricKeysRequest): VerifyAsymmetricKeysResponse;
 }
+export class IncomingMessage {
+  free(): void;
+  constructor(payload: Uint8Array, destination: Endpoint, source: Endpoint, topic?: string | null);
+  /**
+   * Try to parse the payload as JSON.
+   * @returns The parsed JSON value, or undefined if the payload is not valid JSON.
+   */
+  parse_payload_as_json(): any;
+  payload: Uint8Array;
+  destination: Endpoint;
+  source: Endpoint;
+  get topic(): string | undefined;
+  set topic(value: string | null | undefined);
+}
 export class IpcClient {
   free(): void;
   constructor(communication_provider: CommunicationBackend);
   send(message: OutgoingMessage): Promise<void>;
   receive(): Promise<IncomingMessage>;
 }
+export class OutgoingMessage {
+  free(): void;
+  constructor(payload: Uint8Array, destination: Endpoint, topic?: string | null);
+  /**
+   * Create a new message and encode the payload as JSON.
+   */
+  static new_json_payload(
+    payload: any,
+    destination: Endpoint,
+    topic?: string | null,
+  ): OutgoingMessage;
+  payload: Uint8Array;
+  destination: Endpoint;
+  get topic(): string | undefined;
+  set topic(value: string | null | undefined);
+}
 /**
  * This module represents a stopgap solution to provide access to primitive crypto functions for JS
  * clients. It is not intended to be used outside of the JS clients and this pattern should not be
@@ -918,14 +937,15 @@ export class PureCrypto {
 export class ReceiveError {
   private constructor();
   free(): void;
-  crypto_error: any;
-  communication_error: any;
+  timeout: boolean;
+  crypto: any;
+  communication: any;
 }
 export class SendError {
   private constructor();
   free(): void;
-  crypto_error: any;
-  communication_error: any;
+  crypto: any;
+  communication: any;
 }
 export class VaultClient {
   private constructor();

package/bitwarden_wasm_internal_bg.js

@@ -272,6 +272,23 @@ export function isCryptoError(error) {
   }
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
 /**
  * @param {any} error
  * @returns {boolean}
@@ -403,17 +420,6 @@ export function init_sdk(log_level) {
   wasm.init_sdk(isLikeNone(log_level) ? 5 : log_level);
 }
 
-function passArray8ToWasm0(arg, malloc) {
-  const ptr = malloc(arg.length * 1, 1) >>> 0;
-  getUint8ArrayMemory0().set(arg, ptr / 1);
-  WASM_VECTOR_LEN = arg.length;
-  return ptr;
-}
-
-function getArrayU8FromWasm0(ptr, len) {
-  ptr = ptr >>> 0;
-  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
 /**
  * Generate a new SSH key pair
  *
@@ -522,7 +528,7 @@ function __wbg_adapter_50(arg0, arg1, arg2) {
   );
 }
 
-function __wbg_adapter_191(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_215(arg0, arg1, arg2, arg3) {
   wasm.wasm_bindgen__convert__closures__invoke2_mut__h33defb2ea0fdb769(
     arg0,
     arg1,
@@ -1148,6 +1154,145 @@ export class CryptoClient {
   }
 }
 
+const IncomingMessageFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_incomingmessage_free(ptr >>> 0, 1));
+
+export class IncomingMessage {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(IncomingMessage.prototype);
+    obj.__wbg_ptr = ptr;
+    IncomingMessageFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    IncomingMessageFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_incomingmessage_free(ptr, 0);
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  get payload() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_incomingmessage_payload(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var v1 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v1;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @param {Uint8Array} arg0
+   */
+  set payload(arg0) {
+    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.__wbg_set_incomingmessage_payload(this.__wbg_ptr, ptr0, len0);
+  }
+  /**
+   * @returns {Endpoint}
+   */
+  get destination() {
+    const ret = wasm.__wbg_get_incomingmessage_destination(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * @param {Endpoint} arg0
+   */
+  set destination(arg0) {
+    wasm.__wbg_set_incomingmessage_destination(this.__wbg_ptr, addHeapObject(arg0));
+  }
+  /**
+   * @returns {Endpoint}
+   */
+  get source() {
+    const ret = wasm.__wbg_get_incomingmessage_source(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * @param {Endpoint} arg0
+   */
+  set source(arg0) {
+    wasm.__wbg_set_incomingmessage_source(this.__wbg_ptr, addHeapObject(arg0));
+  }
+  /**
+   * @returns {string | undefined}
+   */
+  get topic() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_incomingmessage_topic(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      let v1;
+      if (r0 !== 0) {
+        v1 = getStringFromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 1, 1);
+      }
+      return v1;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @param {string | null} [arg0]
+   */
+  set topic(arg0) {
+    var ptr0 = isLikeNone(arg0)
+      ? 0
+      : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    wasm.__wbg_set_incomingmessage_topic(this.__wbg_ptr, ptr0, len0);
+  }
+  /**
+   * @param {Uint8Array} payload
+   * @param {Endpoint} destination
+   * @param {Endpoint} source
+   * @param {string | null} [topic]
+   */
+  constructor(payload, destination, source, topic) {
+    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(topic)
+      ? 0
+      : passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.incomingmessage_new(
+      ptr0,
+      len0,
+      addHeapObject(destination),
+      addHeapObject(source),
+      ptr1,
+      len1,
+    );
+    this.__wbg_ptr = ret >>> 0;
+    IncomingMessageFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Try to parse the payload as JSON.
+   * @returns {any} The parsed JSON value, or undefined if the payload is not valid JSON.
+   */
+  parse_payload_as_json() {
+    const ret = wasm.incomingmessage_parse_payload_as_json(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+}
+
 const IpcClientFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -1179,7 +1324,9 @@ export class IpcClient {
    * @returns {Promise<void>}
    */
   send(message) {
-    const ret = wasm.ipcclient_send(this.__wbg_ptr, addHeapObject(message));
+    _assertClass(message, OutgoingMessage);
+    var ptr0 = message.__destroy_into_raw();
+    const ret = wasm.ipcclient_send(this.__wbg_ptr, ptr0);
     return takeObject(ret);
   }
   /**
@@ -1191,6 +1338,148 @@ export class IpcClient {
   }
 }
 
+const OutgoingMessageFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_outgoingmessage_free(ptr >>> 0, 1));
+
+export class OutgoingMessage {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(OutgoingMessage.prototype);
+    obj.__wbg_ptr = ptr;
+    OutgoingMessageFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    OutgoingMessageFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_outgoingmessage_free(ptr, 0);
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  get payload() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_outgoingmessage_payload(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var v1 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v1;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @param {Uint8Array} arg0
+   */
+  set payload(arg0) {
+    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.__wbg_set_outgoingmessage_payload(this.__wbg_ptr, ptr0, len0);
+  }
+  /**
+   * @returns {Endpoint}
+   */
+  get destination() {
+    const ret = wasm.__wbg_get_incomingmessage_destination(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * @param {Endpoint} arg0
+   */
+  set destination(arg0) {
+    wasm.__wbg_set_incomingmessage_destination(this.__wbg_ptr, addHeapObject(arg0));
+  }
+  /**
+   * @returns {string | undefined}
+   */
+  get topic() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_outgoingmessage_topic(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      let v1;
+      if (r0 !== 0) {
+        v1 = getStringFromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 1, 1);
+      }
+      return v1;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @param {string | null} [arg0]
+   */
+  set topic(arg0) {
+    var ptr0 = isLikeNone(arg0)
+      ? 0
+      : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    wasm.__wbg_set_outgoingmessage_topic(this.__wbg_ptr, ptr0, len0);
+  }
+  /**
+   * @param {Uint8Array} payload
+   * @param {Endpoint} destination
+   * @param {string | null} [topic]
+   */
+  constructor(payload, destination, topic) {
+    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(topic)
+      ? 0
+      : passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.outgoingmessage_new(ptr0, len0, addHeapObject(destination), ptr1, len1);
+    this.__wbg_ptr = ret >>> 0;
+    OutgoingMessageFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Create a new message and encode the payload as JSON.
+   * @param {any} payload
+   * @param {Endpoint} destination
+   * @param {string | null} [topic]
+   * @returns {OutgoingMessage}
+   */
+  static new_json_payload(payload, destination, topic) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      var ptr0 = isLikeNone(topic)
+        ? 0
+        : passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len0 = WASM_VECTOR_LEN;
+      wasm.outgoingmessage_new_json_payload(
+        retptr,
+        addHeapObject(payload),
+        addHeapObject(destination),
+        ptr0,
+        len0,
+      );
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return OutgoingMessage.__wrap(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+}
+
 const PureCryptoFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -1389,31 +1678,44 @@ export class ReceiveError {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_receiveerror_free(ptr, 0);
   }
+  /**
+   * @returns {boolean}
+   */
+  get timeout() {
+    const ret = wasm.__wbg_get_receiveerror_timeout(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+   * @param {boolean} arg0
+   */
+  set timeout(arg0) {
+    wasm.__wbg_set_receiveerror_timeout(this.__wbg_ptr, arg0);
+  }
   /**
    * @returns {any}
    */
-  get crypto_error() {
-    const ret = wasm.__wbg_get_receiveerror_crypto_error(this.__wbg_ptr);
+  get crypto() {
+    const ret = wasm.__wbg_get_receiveerror_crypto(this.__wbg_ptr);
     return takeObject(ret);
   }
   /**
    * @param {any} arg0
    */
-  set crypto_error(arg0) {
-    wasm.__wbg_set_receiveerror_crypto_error(this.__wbg_ptr, addHeapObject(arg0));
+  set crypto(arg0) {
+    wasm.__wbg_set_receiveerror_crypto(this.__wbg_ptr, addHeapObject(arg0));
   }
   /**
    * @returns {any}
    */
-  get communication_error() {
-    const ret = wasm.__wbg_get_receiveerror_communication_error(this.__wbg_ptr);
+  get communication() {
+    const ret = wasm.__wbg_get_receiveerror_communication(this.__wbg_ptr);
     return takeObject(ret);
   }
   /**
    * @param {any} arg0
    */
-  set communication_error(arg0) {
-    wasm.__wbg_set_receiveerror_communication_error(this.__wbg_ptr, addHeapObject(arg0));
+  set communication(arg0) {
+    wasm.__wbg_set_receiveerror_communication(this.__wbg_ptr, addHeapObject(arg0));
   }
 }
 
@@ -1445,28 +1747,28 @@ export class SendError {
   /**
    * @returns {any}
    */
-  get crypto_error() {
-    const ret = wasm.__wbg_get_receiveerror_crypto_error(this.__wbg_ptr);
+  get crypto() {
+    const ret = wasm.__wbg_get_receiveerror_crypto(this.__wbg_ptr);
     return takeObject(ret);
   }
   /**
    * @param {any} arg0
    */
-  set crypto_error(arg0) {
-    wasm.__wbg_set_receiveerror_crypto_error(this.__wbg_ptr, addHeapObject(arg0));
+  set crypto(arg0) {
+    wasm.__wbg_set_receiveerror_crypto(this.__wbg_ptr, addHeapObject(arg0));
   }
   /**
    * @returns {any}
    */
-  get communication_error() {
-    const ret = wasm.__wbg_get_receiveerror_communication_error(this.__wbg_ptr);
+  get communication() {
+    const ret = wasm.__wbg_get_receiveerror_communication(this.__wbg_ptr);
     return takeObject(ret);
   }
   /**
    * @param {any} arg0
    */
-  set communication_error(arg0) {
-    wasm.__wbg_set_receiveerror_communication_error(this.__wbg_ptr, addHeapObject(arg0));
+  set communication(arg0) {
+    wasm.__wbg_set_receiveerror_communication(this.__wbg_ptr, addHeapObject(arg0));
   }
 }
 
@@ -1662,6 +1964,11 @@ export function __wbg_headers_9cb51cfd2ac780a4(arg0) {
   return addHeapObject(ret);
 }
 
+export function __wbg_incomingmessage_new(arg0) {
+  const ret = IncomingMessage.__wrap(arg0);
+  return addHeapObject(ret);
+}
+
 export function __wbg_info_033d8b8a0838f1d3(arg0, arg1, arg2, arg3) {
   console.info(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
 }
@@ -1763,7 +2070,7 @@ export function __wbg_new_23a2665fac83c611(arg0, arg1) {
       const a = state0.a;
       state0.a = 0;
       try {
-        return __wbg_adapter_191(a, state0.b, arg0, arg1);
+        return __wbg_adapter_215(a, state0.b, arg0, arg1);
       } finally {
         state0.a = a;
       }
@@ -1873,6 +2180,13 @@ export function __wbg_node_02999533c4ea02e3(arg0) {
   return addHeapObject(ret);
 }
 
+export function __wbg_parse_def2e24ef1252aff() {
+  return handleError(function (arg0, arg1) {
+    const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+  }, arguments);
+}
+
 export function __wbg_process_5c1d670bc53614b8(arg0) {
   const ret = getObject(arg0).process;
   return addHeapObject(ret);
@@ -1924,7 +2238,7 @@ export function __wbg_resolve_4851785c9c5f573d(arg0) {
 
 export function __wbg_send_c9eacaae08065b18() {
   return handleError(function (arg0, arg1) {
-    const ret = getObject(arg0).send(takeObject(arg1));
+    const ret = getObject(arg0).send(OutgoingMessage.__wrap(arg1));
     return addHeapObject(ret);
   }, arguments);
 }
@@ -2125,8 +2439,8 @@ export function __wbindgen_cb_drop(arg0) {
   return ret;
 }
 
-export function __wbindgen_closure_wrapper2517(arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 635, __wbg_adapter_50);
+export function __wbindgen_closure_wrapper2552(arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 634, __wbg_adapter_50);
   return addHeapObject(ret);
 }
 

package/bitwarden_wasm_internal_bg.wasm.d.ts

@@ -3,21 +3,56 @@
 export const memory: WebAssembly.Memory;
 export const isEncryptionSettingsError: (a: number) => number;
 export const isCryptoError: (a: number) => number;
+export const __wbg_outgoingmessage_free: (a: number, b: number) => void;
+export const __wbg_get_outgoingmessage_payload: (a: number, b: number) => void;
+export const __wbg_set_outgoingmessage_payload: (a: number, b: number, c: number) => void;
+export const __wbg_get_outgoingmessage_topic: (a: number, b: number) => void;
+export const __wbg_set_outgoingmessage_topic: (a: number, b: number, c: number) => void;
+export const __wbg_incomingmessage_free: (a: number, b: number) => void;
+export const __wbg_get_incomingmessage_payload: (a: number, b: number) => void;
+export const __wbg_set_incomingmessage_payload: (a: number, b: number, c: number) => void;
+export const __wbg_get_incomingmessage_destination: (a: number) => number;
+export const __wbg_set_incomingmessage_destination: (a: number, b: number) => void;
+export const __wbg_get_incomingmessage_source: (a: number) => number;
+export const __wbg_set_incomingmessage_source: (a: number, b: number) => void;
+export const __wbg_get_incomingmessage_topic: (a: number, b: number) => void;
+export const __wbg_set_incomingmessage_topic: (a: number, b: number, c: number) => void;
+export const __wbg_senderror_free: (a: number, b: number) => void;
 export const __wbg_receiveerror_free: (a: number, b: number) => void;
-export const __wbg_get_receiveerror_crypto_error: (a: number) => number;
-export const __wbg_set_receiveerror_crypto_error: (a: number, b: number) => void;
-export const __wbg_get_receiveerror_communication_error: (a: number) => number;
-export const __wbg_set_receiveerror_communication_error: (a: number, b: number) => void;
+export const __wbg_get_receiveerror_timeout: (a: number) => number;
+export const __wbg_set_receiveerror_timeout: (a: number, b: number) => void;
+export const __wbg_get_receiveerror_crypto: (a: number) => number;
+export const __wbg_set_receiveerror_crypto: (a: number, b: number) => void;
+export const __wbg_get_receiveerror_communication: (a: number) => number;
+export const __wbg_set_receiveerror_communication: (a: number, b: number) => void;
 export const __wbg_ipcclient_free: (a: number, b: number) => void;
 export const ipcclient_new: (a: number) => number;
 export const ipcclient_send: (a: number, b: number) => number;
 export const ipcclient_receive: (a: number) => number;
+export const outgoingmessage_new: (a: number, b: number, c: number, d: number, e: number) => number;
+export const outgoingmessage_new_json_payload: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+) => void;
+export const incomingmessage_new: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+  f: number,
+) => number;
+export const incomingmessage_parse_payload_as_json: (a: number) => number;
 export const isDeserializeError: (a: number) => number;
-export const __wbg_set_senderror_crypto_error: (a: number, b: number) => void;
-export const __wbg_set_senderror_communication_error: (a: number, b: number) => void;
-export const __wbg_get_senderror_crypto_error: (a: number) => number;
-export const __wbg_get_senderror_communication_error: (a: number) => number;
-export const __wbg_senderror_free: (a: number, b: number) => void;
+export const __wbg_set_senderror_crypto: (a: number, b: number) => void;
+export const __wbg_set_senderror_communication: (a: number, b: number) => void;
+export const __wbg_get_senderror_crypto: (a: number) => number;
+export const __wbg_get_senderror_communication: (a: number) => number;
+export const __wbg_get_outgoingmessage_destination: (a: number) => number;
+export const __wbg_set_outgoingmessage_destination: (a: number, b: number) => void;
 export const isSshKeyExportError: (a: number) => number;
 export const isSshKeyImportError: (a: number) => number;
 export const isKeyGenerationError: (a: number) => number;