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

package/VERSION

@@ -1 +1 @@
-66e623193b87953d021d911a8a900c79c469469f
+45a2e8b9d325c3bcdc2c0657494e203148e196fd

package/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/bitwarden_wasm_internal_bg.js

@@ -272,6 +272,19 @@ export function isCryptoError(error) {
   }
 }
 
+/**
+ * @param {any} error
+ * @returns {boolean}
+ */
+export function isDeserializeError(error) {
+  try {
+    const ret = wasm.isDeserializeError(addBorrowedObject(error));
+    return ret !== 0;
+  } finally {
+    heap[stack_pointer++] = undefined;
+  }
+}
+
 /**
  * @param {any} error
  * @returns {boolean}
@@ -490,7 +503,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,
@@ -839,6 +852,49 @@ export class CryptoClient {
   }
 }
 
+const IpcClientFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_ipcclient_free(ptr >>> 0, 1));
+
+export 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);
+  }
+}
+
 const PureCryptoFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -1012,6 +1068,112 @@ export class PureCrypto {
   }
 }
 
+const ReceiveErrorFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_receiveerror_free(ptr >>> 0, 1));
+
+export 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));
+  }
+}
+
+const SendErrorFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_senderror_free(ptr >>> 0, 1));
+
+export 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));
+  }
+}
+
 const VaultClientFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -1234,6 +1396,11 @@ export function __wbg_instanceof_Uint8Array_17156bcf118086a9(arg0) {
   return ret;
 }
 
+export function __wbg_isArray_a1eab7e0d067391b(arg0) {
+  const ret = Array.isArray(getObject(arg0));
+  return ret;
+}
+
 export function __wbg_isSafeInteger_343e2beeeece1bb0(arg0) {
   const ret = Number.isSafeInteger(getObject(arg0));
   return ret;
@@ -1282,7 +1449,7 @@ export function __wbg_new_23a2665fac83c611(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 +1584,18 @@ export function __wbg_randomFillSync_ab2cfe79ebbf2740() {
   }, arguments);
 }
 
+export function __wbg_receive_9512d555fb8b5130() {
+  return handleError(function (arg0) {
+    const ret = getObject(arg0).receive();
+    return addHeapObject(ret);
+  }, arguments);
+}
+
+export function __wbg_receiveerror_new(arg0) {
+  const ret = ReceiveError.__wrap(arg0);
+  return addHeapObject(ret);
+}
+
 export function __wbg_require_79b1e9274cde3c87() {
   return handleError(function () {
     const ret = module.require;
@@ -1429,6 +1608,22 @@ export function __wbg_resolve_4851785c9c5f573d(arg0) {
   return addHeapObject(ret);
 }
 
+export function __wbg_send_c9eacaae08065b18() {
+  return handleError(function (arg0, arg1) {
+    const ret = getObject(arg0).send(takeObject(arg1));
+    return addHeapObject(ret);
+  }, arguments);
+}
+
+export function __wbg_senderror_new(arg0) {
+  const ret = SendError.__wrap(arg0);
+  return addHeapObject(ret);
+}
+
+export function __wbg_set_37837023f3d740e8(arg0, arg1, arg2) {
+  getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+}
+
 export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
   getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
 }
@@ -1599,8 +1794,8 @@ export function __wbindgen_cb_drop(arg0) {
   return ret;
 }
 
-export function __wbindgen_closure_wrapper2148(arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 548, __wbg_adapter_40);
+export function __wbindgen_closure_wrapper2219(arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 574, __wbg_adapter_40);
   return addHeapObject(ret);
 }
 

package/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;