@bitwarden/sdk-internal 0.2.0-main.131 → 0.2.0-main.133

package/node/bitwarden_wasm_internal.d.ts

@@ -227,6 +227,35 @@ export interface CryptoError extends Error {
 
 export function isCryptoError(error: any): error is CryptoError;
 
+export type Endpoint =
+  | { Web: { id: number } }
+  | "BrowserForeground"
+  | "BrowserBackground"
+  | "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>;
+}
+
+export interface DeserializeError extends Error {
+  name: "DeserializeError";
+}
+
+export function isDeserializeError(error: any): error is DeserializeError;
+
 export type KeyAlgorithm = "Ed25519" | "Rsa3072" | "Rsa4096";
 
 export interface SshKeyExportError extends Error {
@@ -415,6 +444,12 @@ export class CryptoClient {
    */
   verify_asymmetric_keys(request: VerifyAsymmetricKeysRequest): VerifyAsymmetricKeysResponse;
 }
+export class IpcClient {
+  free(): void;
+  constructor(communication_provider: CommunicationBackend);
+  send(message: OutgoingMessage): Promise<void>;
+  receive(): Promise<IncomingMessage>;
+}
 /**
  * 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
@@ -430,6 +465,18 @@ export class PureCrypto {
   static symmetric_encrypt(plain: string, key: Uint8Array): string;
   static symmetric_encrypt_to_array_buffer(plain: Uint8Array, key: Uint8Array): Uint8Array;
 }
+export class ReceiveError {
+  private constructor();
+  free(): void;
+  crypto_error: any;
+  communication_error: any;
+}
+export class SendError {
+  private constructor();
+  free(): void;
+  crypto_error: any;
+  communication_error: any;
+}
 export class VaultClient {
   private constructor();
   free(): void;

package/node/bitwarden_wasm_internal.js

@@ -266,6 +266,19 @@ module.exports.isCryptoError = function (error) {
   }
 };
 
+/**
+ * @param {any} error
+ * @returns {boolean}
+ */
+module.exports.isDeserializeError = function (error) {
+  try {
+    const ret = wasm.isDeserializeError(addBorrowedObject(error));
+    return ret !== 0;
+  } finally {
+    heap[stack_pointer++] = undefined;
+  }
+};
+
 /**
  * @param {any} error
  * @returns {boolean}
@@ -484,7 +497,7 @@ function __wbg_adapter_40(arg0, arg1, arg2) {
   );
 }
 
-function __wbg_adapter_150(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_174(arg0, arg1, arg2, arg3) {
   wasm.wasm_bindgen__convert__closures__invoke2_mut__h33defb2ea0fdb769(
     arg0,
     arg1,
@@ -837,6 +850,50 @@ class CryptoClient {
 }
 module.exports.CryptoClient = CryptoClient;
 
+const IpcClientFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_ipcclient_free(ptr >>> 0, 1));
+
+class IpcClient {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    IpcClientFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_ipcclient_free(ptr, 0);
+  }
+  /**
+   * @param {CommunicationBackend} communication_provider
+   */
+  constructor(communication_provider) {
+    const ret = wasm.ipcclient_new(addHeapObject(communication_provider));
+    this.__wbg_ptr = ret >>> 0;
+    IpcClientFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {OutgoingMessage} message
+   * @returns {Promise<void>}
+   */
+  send(message) {
+    const ret = wasm.ipcclient_send(this.__wbg_ptr, addHeapObject(message));
+    return takeObject(ret);
+  }
+  /**
+   * @returns {Promise<IncomingMessage>}
+   */
+  receive() {
+    const ret = wasm.ipcclient_receive(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+}
+module.exports.IpcClient = IpcClient;
+
 const PureCryptoFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -1011,6 +1068,114 @@ class PureCrypto {
 }
 module.exports.PureCrypto = PureCrypto;
 
+const ReceiveErrorFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_receiveerror_free(ptr >>> 0, 1));
+
+class ReceiveError {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(ReceiveError.prototype);
+    obj.__wbg_ptr = ptr;
+    ReceiveErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    ReceiveErrorFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_receiveerror_free(ptr, 0);
+  }
+  /**
+   * @returns {any}
+   */
+  get crypto_error() {
+    const ret = wasm.__wbg_get_receiveerror_crypto_error(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * @param {any} arg0
+   */
+  set crypto_error(arg0) {
+    wasm.__wbg_set_receiveerror_crypto_error(this.__wbg_ptr, addHeapObject(arg0));
+  }
+  /**
+   * @returns {any}
+   */
+  get communication_error() {
+    const ret = wasm.__wbg_get_receiveerror_communication_error(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * @param {any} arg0
+   */
+  set communication_error(arg0) {
+    wasm.__wbg_set_receiveerror_communication_error(this.__wbg_ptr, addHeapObject(arg0));
+  }
+}
+module.exports.ReceiveError = ReceiveError;
+
+const SendErrorFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_senderror_free(ptr >>> 0, 1));
+
+class SendError {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(SendError.prototype);
+    obj.__wbg_ptr = ptr;
+    SendErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    SendErrorFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_senderror_free(ptr, 0);
+  }
+  /**
+   * @returns {any}
+   */
+  get crypto_error() {
+    const ret = wasm.__wbg_get_receiveerror_crypto_error(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * @param {any} arg0
+   */
+  set crypto_error(arg0) {
+    wasm.__wbg_set_receiveerror_crypto_error(this.__wbg_ptr, addHeapObject(arg0));
+  }
+  /**
+   * @returns {any}
+   */
+  get communication_error() {
+    const ret = wasm.__wbg_get_receiveerror_communication_error(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * @param {any} arg0
+   */
+  set communication_error(arg0) {
+    wasm.__wbg_set_receiveerror_communication_error(this.__wbg_ptr, addHeapObject(arg0));
+  }
+}
+module.exports.SendError = SendError;
+
 const VaultClientFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -1234,6 +1399,11 @@ module.exports.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function (arg0) {
   return ret;
 };
 
+module.exports.__wbg_isArray_a1eab7e0d067391b = function (arg0) {
+  const ret = Array.isArray(getObject(arg0));
+  return ret;
+};
+
 module.exports.__wbg_isSafeInteger_343e2beeeece1bb0 = function (arg0) {
   const ret = Number.isSafeInteger(getObject(arg0));
   return ret;
@@ -1282,7 +1452,7 @@ module.exports.__wbg_new_23a2665fac83c611 = function (arg0, arg1) {
       const a = state0.a;
       state0.a = 0;
       try {
-        return __wbg_adapter_150(a, state0.b, arg0, arg1);
+        return __wbg_adapter_174(a, state0.b, arg0, arg1);
       } finally {
         state0.a = a;
       }
@@ -1417,6 +1587,18 @@ module.exports.__wbg_randomFillSync_ab2cfe79ebbf2740 = function () {
   }, arguments);
 };
 
+module.exports.__wbg_receive_9512d555fb8b5130 = function () {
+  return handleError(function (arg0) {
+    const ret = getObject(arg0).receive();
+    return addHeapObject(ret);
+  }, arguments);
+};
+
+module.exports.__wbg_receiveerror_new = function (arg0) {
+  const ret = ReceiveError.__wrap(arg0);
+  return addHeapObject(ret);
+};
+
 module.exports.__wbg_require_79b1e9274cde3c87 = function () {
   return handleError(function () {
     const ret = module.require;
@@ -1429,6 +1611,22 @@ module.exports.__wbg_resolve_4851785c9c5f573d = function (arg0) {
   return addHeapObject(ret);
 };
 
+module.exports.__wbg_send_c9eacaae08065b18 = function () {
+  return handleError(function (arg0, arg1) {
+    const ret = getObject(arg0).send(takeObject(arg1));
+    return addHeapObject(ret);
+  }, arguments);
+};
+
+module.exports.__wbg_senderror_new = function (arg0) {
+  const ret = SendError.__wrap(arg0);
+  return addHeapObject(ret);
+};
+
+module.exports.__wbg_set_37837023f3d740e8 = function (arg0, arg1, arg2) {
+  getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+};
+
 module.exports.__wbg_set_3f1d0b984ed272ed = function (arg0, arg1, arg2) {
   getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
 };
@@ -1599,8 +1797,8 @@ module.exports.__wbindgen_cb_drop = function (arg0) {
   return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper2148 = function (arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 548, __wbg_adapter_40);
+module.exports.__wbindgen_closure_wrapper2219 = function (arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 574, __wbg_adapter_40);
   return addHeapObject(ret);
 };
 

package/node/bitwarden_wasm_internal_bg.wasm.d.ts

@@ -3,6 +3,21 @@
 export const memory: WebAssembly.Memory;
 export const isEncryptionSettingsError: (a: number) => number;
 export const isCryptoError: (a: number) => number;
+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_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 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 isSshKeyExportError: (a: number) => number;
 export const isSshKeyImportError: (a: number) => number;
 export const isKeyGenerationError: (a: number) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitwarden/sdk-internal",
-  "version": "0.2.0-main.131",
+  "version": "0.2.0-main.133",
   "license": "GPL-3.0",
   "files": [
     "bitwarden_wasm_internal_bg.js",