cojson-core-rn 0.19.10

package/lib/module/generated/cojson_core_rn.js

@@ -0,0 +1,1311 @@
+"use strict";
+
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+import nativeModule from "./cojson_core_rn-ffi.js";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterFloat64, FfiConverterInt32, FfiConverterObject, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, UniffiError, UniffiInternalError, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiTypeNameSymbol } from 'uniffi-bindgen-react-native';
+
+// Get converters from the other files, if any.
+const uniffiCaller = new UniffiRustCaller(() => ({
+  code: 0
+}));
+const uniffiIsDebug =
+// @ts-ignore -- The process global might not be defined
+typeof process !== 'object' ||
+// @ts-ignore -- The process global might not be defined
+process?.env?.NODE_ENV !== 'production' || false;
+// Public interface members begin here.
+
+/**
+ * Hash data once using BLAKE3.
+ * - `data`: Raw bytes to hash
+ * Returns 32 bytes of hash output.
+ * This is the simplest way to compute a BLAKE3 hash of a single piece of data.
+ */
+export function blake3HashOnce(data) {
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_blake3_hash_once(FfiConverterArrayBuffer.lower(data), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Hash data once using BLAKE3 with a context prefix.
+ * - `data`: Raw bytes to hash
+ * - `context`: Context bytes to prefix to the data
+ * Returns 32 bytes of hash output.
+ * This is useful for domain separation - the same data hashed with different contexts will produce different outputs.
+ */
+export function blake3HashOnceWithContext(data, context) {
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_blake3_hash_once_with_context(FfiConverterArrayBuffer.lower(data), FfiConverterArrayBuffer.lower(context), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function to decrypt bytes with a key secret and nonce material.
+ * - `ciphertext`: The encrypted bytes to decrypt
+ * - `key_secret`: A base58-encoded key secret with "keySecret_z" prefix
+ * - `nonce_material`: Raw bytes used to generate the nonce (must match encryption)
+ * Returns the decrypted bytes or throws an error if decryption fails.
+ */
+export function decrypt(ciphertext, keySecret, nonceMaterial) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_decrypt(FfiConverterArrayBuffer.lower(ciphertext), FfiConverterString.lower(keySecret), FfiConverterArrayBuffer.lower(nonceMaterial), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function for XSalsa20 decryption without authentication.
+ * - `key`: 32-byte key for decryption (must match encryption key)
+ * - `nonce_material`: Raw bytes used to generate a 24-byte nonce (must match encryption)
+ * - `ciphertext`: Encrypted bytes to decrypt
+ * Returns the decrypted bytes or throws an error if decryption fails.
+ * Note: This function does not provide authentication. Use decrypt_xsalsa20_poly1305 for authenticated decryption.
+ */
+export function decryptXsalsa20(key, nonceMaterial, ciphertext) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_decrypt_xsalsa20(FfiConverterArrayBuffer.lower(key), FfiConverterArrayBuffer.lower(nonceMaterial), FfiConverterArrayBuffer.lower(ciphertext), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * uniffi-exposed function to sign a message using Ed25519.
+ * - `signing_key`: 32 bytes of signing key material
+ * - `message`: Raw bytes to sign
+ * Returns 64 bytes of signature material or throws CryptoErrorUniffi if signing fails.
+ */
+export function ed25519Sign(signingKey, message) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_ed25519_sign(FfiConverterArrayBuffer.lower(signingKey), FfiConverterArrayBuffer.lower(message), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * uniffi-exposed function to validate and copy Ed25519 signature bytes.
+ * - `bytes`: 64 bytes of signature material to validate
+ * Returns the same 64 bytes if valid or throws CryptoErrorUniffi if invalid.
+ */
+export function ed25519SignatureFromBytes(bytes) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_ed25519_signature_from_bytes(FfiConverterArrayBuffer.lower(bytes), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * uniffi-exposed function to validate and copy Ed25519 signing key bytes.
+ * - `bytes`: 32 bytes of signing key material to validate
+ * Returns the same 32 bytes if valid or throws CryptoErrorUniffi if invalid.
+ */
+export function ed25519SigningKeyFromBytes(bytes) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_ed25519_signing_key_from_bytes(FfiConverterArrayBuffer.lower(bytes), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * uniffi-exposed function to sign a message with an Ed25519 signing key.
+ * - `signing_key`: 32 bytes of signing key material
+ * - `message`: Raw bytes to sign
+ * Returns 64 bytes of signature material or throws CryptoErrorUniffi if signing fails.
+ */
+export function ed25519SigningKeySign(signingKey, message) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_ed25519_signing_key_sign(FfiConverterArrayBuffer.lower(signingKey), FfiConverterArrayBuffer.lower(message), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * uniffi-exposed function to derive the public key from an Ed25519 signing key.
+ * - `signing_key`: 32 bytes of signing key material
+ * Returns 32 bytes of public key material or throws CryptoErrorUniffi if key is invalid.
+ */
+export function ed25519SigningKeyToPublic(signingKey) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_ed25519_signing_key_to_public(FfiConverterArrayBuffer.lower(signingKey), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * uniffi-exposed function to verify an Ed25519 signature.
+ * - `verifying_key`: 32 bytes of verifying key material
+ * - `message`: Raw bytes that were signed
+ * - `signature`: 64 bytes of signature material
+ * Returns true if signature is valid, false otherwise, or throws CryptoErrorUniffi if verification fails.
+ */
+export function ed25519Verify(verifyingKey, message, signature) /*throws*/{
+  return FfiConverterBool.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_ed25519_verify(FfiConverterArrayBuffer.lower(verifyingKey), FfiConverterArrayBuffer.lower(message), FfiConverterArrayBuffer.lower(signature), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * uniffi-exposed function to derive an Ed25519 verifying key from a signing key.
+ * - `signing_key`: 32 bytes of signing key material
+ * Returns 32 bytes of verifying key material or throws CryptoErrorUniffi if key is invalid.
+ */
+export function ed25519VerifyingKey(signingKey) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_ed25519_verifying_key(FfiConverterArrayBuffer.lower(signingKey), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * uniffi-exposed function to validate and copy Ed25519 verifying key bytes.
+ * - `bytes`: 32 bytes of verifying key material to validate
+ * Returns the same 32 bytes if valid or throws CryptoErrorUniffi if invalid.
+ */
+export function ed25519VerifyingKeyFromBytes(bytes) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_ed25519_verifying_key_from_bytes(FfiConverterArrayBuffer.lower(bytes), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function to encrypt bytes with a key secret and nonce material.
+ * - `value`: The raw bytes to encrypt
+ * - `key_secret`: A base58-encoded key secret with "keySecret_z" prefix
+ * - `nonce_material`: Raw bytes used to generate the nonce
+ * Returns the encrypted bytes or throws an error if encryption fails.
+ */
+export function encrypt(value, keySecret, nonceMaterial) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_encrypt(FfiConverterArrayBuffer.lower(value), FfiConverterString.lower(keySecret), FfiConverterArrayBuffer.lower(nonceMaterial), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function for XSalsa20 encryption without authentication.
+ * - `key`: 32-byte key for encryption
+ * - `nonce_material`: Raw bytes used to generate a 24-byte nonce via BLAKE3
+ * - `plaintext`: Raw bytes to encrypt
+ * Returns the encrypted bytes or throws an error if encryption fails.
+ * Note: This function does not provide authentication. Use encrypt_xsalsa20_poly1305 for authenticated encryption.
+ */
+export function encryptXsalsa20(key, nonceMaterial, plaintext) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_encrypt_xsalsa20(FfiConverterArrayBuffer.lower(key), FfiConverterArrayBuffer.lower(nonceMaterial), FfiConverterArrayBuffer.lower(plaintext), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Generate a 24-byte nonce from input material using BLAKE3.
+ * - `nonce_material`: Raw bytes to derive the nonce from
+ * Returns 24 bytes suitable for use as a nonce in cryptographic operations.
+ * This function is deterministic - the same input will produce the same nonce.
+ */
+export function generateNonce(nonceMaterial) {
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_generate_nonce(FfiConverterArrayBuffer.lower(nonceMaterial), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function to derive a sealer ID from a sealer secret.
+ * - `secret`: UTF-8 encoded sealer secret string
+ * Returns a base58-encoded sealer ID with "sealer_z" prefix or throws an error if derivation fails.
+ */
+export function getSealerId(secret) /*throws*/{
+  return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_get_sealer_id(FfiConverterString.lower(secret), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function to derive a signer ID from a signing key.
+ * - `secret`: UTF-8 encoded Ed25519 signing key string
+ * Returns base58-encoded verifying key with "signer_z" prefix or throws an error if derivation fails.
+ */
+export function getSignerId(secret) /*throws*/{
+  return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_get_signer_id(FfiConverterString.lower(secret), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Generate a new Ed25519 signing key using secure random number generation.
+ * Returns 32 bytes of raw key material suitable for use with other Ed25519 functions.
+ */
+export function newEd25519SigningKey() {
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_new_ed25519_signing_key(callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Generate a new X25519 private key using secure random number generation.
+ * Returns 32 bytes of raw key material suitable for use with other X25519 functions.
+ * This key can be reused for multiple Diffie-Hellman exchanges.
+ */
+export function newX25519PrivateKey() {
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_new_x25519_private_key(callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function for sealing a message using X25519 + XSalsa20-Poly1305.
+ * Provides authenticated encryption with perfect forward secrecy.
+ * - `message`: Raw bytes to seal
+ * - `sender_secret`: Base58-encoded sender's private key with "sealerSecret_z" prefix
+ * - `recipient_id`: Base58-encoded recipient's public key with "sealer_z" prefix
+ * - `nonce_material`: Raw bytes used to generate the nonce
+ * Returns sealed bytes or throws an error if sealing fails.
+ */
+export function seal(message, senderSecret, recipientId, nonceMaterial) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_seal(FfiConverterArrayBuffer.lower(message), FfiConverterString.lower(senderSecret), FfiConverterString.lower(recipientId), FfiConverterArrayBuffer.lower(nonceMaterial), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function to sign a message using Ed25519.
+ * - `message`: Raw bytes to sign
+ * - `secret`: UTF-8 encoded Ed25519 signing key string
+ * Returns base58-encoded signature with "signature_z" prefix or throws an error if signing fails.
+ */
+export function sign(message, secret) /*throws*/{
+  return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_sign(FfiConverterArrayBuffer.lower(message), FfiConverterString.lower(secret), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function for unsealing a message using X25519 + XSalsa20-Poly1305.
+ * Provides authenticated decryption with perfect forward secrecy.
+ * - `sealed_message`: The sealed bytes to decrypt
+ * - `recipient_secret`: Base58-encoded recipient's private key with "sealerSecret_z" prefix
+ * - `sender_id`: Base58-encoded sender's public key with "sealer_z" prefix
+ * - `nonce_material`: Raw bytes used to generate the nonce (must match sealing)
+ * Returns unsealed bytes or throws an error if unsealing fails.
+ */
+export function unseal(sealedMessage, recipientSecret, senderId, nonceMaterial) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_unseal(FfiConverterArrayBuffer.lower(sealedMessage), FfiConverterString.lower(recipientSecret), FfiConverterString.lower(senderId), FfiConverterArrayBuffer.lower(nonceMaterial), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function to verify an Ed25519 signature.
+ * - `signature`: Base58-encoded signature string
+ * - `message`: Raw bytes that were signed
+ * - `id`: Base58-encoded verifying key string
+ * Returns true if signature is valid, false otherwise, or throws an error if verification fails.
+ */
+export function verify(signature, message, id) /*throws*/{
+  return FfiConverterBool.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_verify(FfiConverterString.lower(signature), FfiConverterArrayBuffer.lower(message), FfiConverterString.lower(id), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function to perform X25519 Diffie-Hellman key exchange.
+ * - `private_key`: 32 bytes of private key material
+ * - `public_key`: 32 bytes of public key material
+ * Returns 32 bytes of shared secret material or throws an error if key exchange fails.
+ */
+export function x25519DiffieHellman(privateKey, publicKey) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_x25519_diffie_hellman(FfiConverterArrayBuffer.lower(privateKey), FfiConverterArrayBuffer.lower(publicKey), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+/**
+ * Uniffi-exposed function to derive an X25519 public key from a private key.
+ * - `private_key`: 32 bytes of private key material
+ * Returns 32 bytes of public key material or throws an error if key is invalid.
+ */
+export function x25519PublicKey(privateKey) /*throws*/{
+  return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeCryptoErrorUniffi.lift.bind(FfiConverterTypeCryptoErrorUniffi), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_cojson_core_rn_fn_func_x25519_public_key(FfiConverterArrayBuffer.lower(privateKey), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+const stringConverter = {
+  stringToBytes: s => uniffiCaller.rustCall(status => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_arraybuffer(s, status)),
+  bytesToString: ab => uniffiCaller.rustCall(status => nativeModule().ubrn_uniffi_internal_fn_func_ffi__arraybuffer_to_string(ab, status)),
+  stringByteLength: s => uniffiCaller.rustCall(status => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(s, status))
+};
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+// Error type: Blake3Error
+
+// Enum: Blake3Error
+export let Blake3Error_Tags = /*#__PURE__*/function (Blake3Error_Tags) {
+  Blake3Error_Tags["LockError"] = "LockError";
+  return Blake3Error_Tags;
+}({});
+export const Blake3Error = (() => {
+  class LockError_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'Blake3Error';
+    tag = Blake3Error_Tags.LockError;
+    constructor() {
+      super('Blake3Error', 'LockError');
+    }
+    static new() {
+      return new LockError_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === Blake3Error_Tags.LockError;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === 'Blake3Error';
+  }
+  return Object.freeze({
+    instanceOf,
+    LockError: LockError_
+  });
+})();
+// FfiConverter for enum Blake3Error
+const FfiConverterTypeBlake3Error = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new Blake3Error.LockError();
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value, into) {
+      switch (value.tag) {
+        case Blake3Error_Tags.LockError:
+          {
+            ordinalConverter.write(1, into);
+            return;
+          }
+        default:
+          // Throwing from here means that Blake3Error_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case Blake3Error_Tags.LockError:
+          {
+            return ordinalConverter.allocationSize(1);
+          }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Error type: CryptoErrorUniffi
+
+// Enum: CryptoErrorUniffi
+export let CryptoErrorUniffi_Tags = /*#__PURE__*/function (CryptoErrorUniffi_Tags) {
+  CryptoErrorUniffi_Tags["InvalidKeyLength"] = "InvalidKeyLength";
+  CryptoErrorUniffi_Tags["InvalidNonceLength"] = "InvalidNonceLength";
+  CryptoErrorUniffi_Tags["InvalidSealerSecretFormat"] = "InvalidSealerSecretFormat";
+  CryptoErrorUniffi_Tags["InvalidSignatureLength"] = "InvalidSignatureLength";
+  CryptoErrorUniffi_Tags["InvalidVerifyingKey"] = "InvalidVerifyingKey";
+  CryptoErrorUniffi_Tags["InvalidPublicKey"] = "InvalidPublicKey";
+  CryptoErrorUniffi_Tags["WrongTag"] = "WrongTag";
+  CryptoErrorUniffi_Tags["CipherError"] = "CipherError";
+  CryptoErrorUniffi_Tags["InvalidPrefix"] = "InvalidPrefix";
+  CryptoErrorUniffi_Tags["Base58Error"] = "Base58Error";
+  return CryptoErrorUniffi_Tags;
+}({});
+export const CryptoErrorUniffi = (() => {
+  class InvalidKeyLength_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'CryptoErrorUniffi';
+    tag = CryptoErrorUniffi_Tags.InvalidKeyLength;
+    constructor(v0, v1) {
+      super('CryptoErrorUniffi', 'InvalidKeyLength');
+      this.inner = Object.freeze([v0, v1]);
+    }
+    static new(v0, v1) {
+      return new InvalidKeyLength_(v0, v1);
+    }
+    static instanceOf(obj) {
+      return obj.tag === CryptoErrorUniffi_Tags.InvalidKeyLength;
+    }
+    static hasInner(obj) {
+      return InvalidKeyLength_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class InvalidNonceLength_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'CryptoErrorUniffi';
+    tag = CryptoErrorUniffi_Tags.InvalidNonceLength;
+    constructor() {
+      super('CryptoErrorUniffi', 'InvalidNonceLength');
+    }
+    static new() {
+      return new InvalidNonceLength_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === CryptoErrorUniffi_Tags.InvalidNonceLength;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
+  class InvalidSealerSecretFormat_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'CryptoErrorUniffi';
+    tag = CryptoErrorUniffi_Tags.InvalidSealerSecretFormat;
+    constructor() {
+      super('CryptoErrorUniffi', 'InvalidSealerSecretFormat');
+    }
+    static new() {
+      return new InvalidSealerSecretFormat_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === CryptoErrorUniffi_Tags.InvalidSealerSecretFormat;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
+  class InvalidSignatureLength_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'CryptoErrorUniffi';
+    tag = CryptoErrorUniffi_Tags.InvalidSignatureLength;
+    constructor() {
+      super('CryptoErrorUniffi', 'InvalidSignatureLength');
+    }
+    static new() {
+      return new InvalidSignatureLength_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === CryptoErrorUniffi_Tags.InvalidSignatureLength;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
+  class InvalidVerifyingKey_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'CryptoErrorUniffi';
+    tag = CryptoErrorUniffi_Tags.InvalidVerifyingKey;
+    constructor(v0) {
+      super('CryptoErrorUniffi', 'InvalidVerifyingKey');
+      this.inner = Object.freeze([v0]);
+    }
+    static new(v0) {
+      return new InvalidVerifyingKey_(v0);
+    }
+    static instanceOf(obj) {
+      return obj.tag === CryptoErrorUniffi_Tags.InvalidVerifyingKey;
+    }
+    static hasInner(obj) {
+      return InvalidVerifyingKey_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class InvalidPublicKey_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'CryptoErrorUniffi';
+    tag = CryptoErrorUniffi_Tags.InvalidPublicKey;
+    constructor(v0) {
+      super('CryptoErrorUniffi', 'InvalidPublicKey');
+      this.inner = Object.freeze([v0]);
+    }
+    static new(v0) {
+      return new InvalidPublicKey_(v0);
+    }
+    static instanceOf(obj) {
+      return obj.tag === CryptoErrorUniffi_Tags.InvalidPublicKey;
+    }
+    static hasInner(obj) {
+      return InvalidPublicKey_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class WrongTag_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'CryptoErrorUniffi';
+    tag = CryptoErrorUniffi_Tags.WrongTag;
+    constructor() {
+      super('CryptoErrorUniffi', 'WrongTag');
+    }
+    static new() {
+      return new WrongTag_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === CryptoErrorUniffi_Tags.WrongTag;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
+  class CipherError_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'CryptoErrorUniffi';
+    tag = CryptoErrorUniffi_Tags.CipherError;
+    constructor() {
+      super('CryptoErrorUniffi', 'CipherError');
+    }
+    static new() {
+      return new CipherError_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === CryptoErrorUniffi_Tags.CipherError;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
+  class InvalidPrefix_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'CryptoErrorUniffi';
+    tag = CryptoErrorUniffi_Tags.InvalidPrefix;
+    constructor(v0, v1) {
+      super('CryptoErrorUniffi', 'InvalidPrefix');
+      this.inner = Object.freeze([v0, v1]);
+    }
+    static new(v0, v1) {
+      return new InvalidPrefix_(v0, v1);
+    }
+    static instanceOf(obj) {
+      return obj.tag === CryptoErrorUniffi_Tags.InvalidPrefix;
+    }
+    static hasInner(obj) {
+      return InvalidPrefix_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class Base58Error_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'CryptoErrorUniffi';
+    tag = CryptoErrorUniffi_Tags.Base58Error;
+    constructor(v0) {
+      super('CryptoErrorUniffi', 'Base58Error');
+      this.inner = Object.freeze([v0]);
+    }
+    static new(v0) {
+      return new Base58Error_(v0);
+    }
+    static instanceOf(obj) {
+      return obj.tag === CryptoErrorUniffi_Tags.Base58Error;
+    }
+    static hasInner(obj) {
+      return Base58Error_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === 'CryptoErrorUniffi';
+  }
+  return Object.freeze({
+    instanceOf,
+    InvalidKeyLength: InvalidKeyLength_,
+    InvalidNonceLength: InvalidNonceLength_,
+    InvalidSealerSecretFormat: InvalidSealerSecretFormat_,
+    InvalidSignatureLength: InvalidSignatureLength_,
+    InvalidVerifyingKey: InvalidVerifyingKey_,
+    InvalidPublicKey: InvalidPublicKey_,
+    WrongTag: WrongTag_,
+    CipherError: CipherError_,
+    InvalidPrefix: InvalidPrefix_,
+    Base58Error: Base58Error_
+  });
+})();
+// FfiConverter for enum CryptoErrorUniffi
+const FfiConverterTypeCryptoErrorUniffi = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new CryptoErrorUniffi.InvalidKeyLength(FfiConverterUInt64.read(from), FfiConverterUInt64.read(from));
+        case 2:
+          return new CryptoErrorUniffi.InvalidNonceLength();
+        case 3:
+          return new CryptoErrorUniffi.InvalidSealerSecretFormat();
+        case 4:
+          return new CryptoErrorUniffi.InvalidSignatureLength();
+        case 5:
+          return new CryptoErrorUniffi.InvalidVerifyingKey(FfiConverterString.read(from));
+        case 6:
+          return new CryptoErrorUniffi.InvalidPublicKey(FfiConverterString.read(from));
+        case 7:
+          return new CryptoErrorUniffi.WrongTag();
+        case 8:
+          return new CryptoErrorUniffi.CipherError();
+        case 9:
+          return new CryptoErrorUniffi.InvalidPrefix(FfiConverterString.read(from), FfiConverterString.read(from));
+        case 10:
+          return new CryptoErrorUniffi.Base58Error(FfiConverterString.read(from));
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value, into) {
+      switch (value.tag) {
+        case CryptoErrorUniffi_Tags.InvalidKeyLength:
+          {
+            ordinalConverter.write(1, into);
+            const inner = value.inner;
+            FfiConverterUInt64.write(inner[0], into);
+            FfiConverterUInt64.write(inner[1], into);
+            return;
+          }
+        case CryptoErrorUniffi_Tags.InvalidNonceLength:
+          {
+            ordinalConverter.write(2, into);
+            return;
+          }
+        case CryptoErrorUniffi_Tags.InvalidSealerSecretFormat:
+          {
+            ordinalConverter.write(3, into);
+            return;
+          }
+        case CryptoErrorUniffi_Tags.InvalidSignatureLength:
+          {
+            ordinalConverter.write(4, into);
+            return;
+          }
+        case CryptoErrorUniffi_Tags.InvalidVerifyingKey:
+          {
+            ordinalConverter.write(5, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner[0], into);
+            return;
+          }
+        case CryptoErrorUniffi_Tags.InvalidPublicKey:
+          {
+            ordinalConverter.write(6, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner[0], into);
+            return;
+          }
+        case CryptoErrorUniffi_Tags.WrongTag:
+          {
+            ordinalConverter.write(7, into);
+            return;
+          }
+        case CryptoErrorUniffi_Tags.CipherError:
+          {
+            ordinalConverter.write(8, into);
+            return;
+          }
+        case CryptoErrorUniffi_Tags.InvalidPrefix:
+          {
+            ordinalConverter.write(9, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner[0], into);
+            FfiConverterString.write(inner[1], into);
+            return;
+          }
+        case CryptoErrorUniffi_Tags.Base58Error:
+          {
+            ordinalConverter.write(10, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner[0], into);
+            return;
+          }
+        default:
+          // Throwing from here means that CryptoErrorUniffi_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case CryptoErrorUniffi_Tags.InvalidKeyLength:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(1);
+            size += FfiConverterUInt64.allocationSize(inner[0]);
+            size += FfiConverterUInt64.allocationSize(inner[1]);
+            return size;
+          }
+        case CryptoErrorUniffi_Tags.InvalidNonceLength:
+          {
+            return ordinalConverter.allocationSize(2);
+          }
+        case CryptoErrorUniffi_Tags.InvalidSealerSecretFormat:
+          {
+            return ordinalConverter.allocationSize(3);
+          }
+        case CryptoErrorUniffi_Tags.InvalidSignatureLength:
+          {
+            return ordinalConverter.allocationSize(4);
+          }
+        case CryptoErrorUniffi_Tags.InvalidVerifyingKey:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(5);
+            size += FfiConverterString.allocationSize(inner[0]);
+            return size;
+          }
+        case CryptoErrorUniffi_Tags.InvalidPublicKey:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(6);
+            size += FfiConverterString.allocationSize(inner[0]);
+            return size;
+          }
+        case CryptoErrorUniffi_Tags.WrongTag:
+          {
+            return ordinalConverter.allocationSize(7);
+          }
+        case CryptoErrorUniffi_Tags.CipherError:
+          {
+            return ordinalConverter.allocationSize(8);
+          }
+        case CryptoErrorUniffi_Tags.InvalidPrefix:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(9);
+            size += FfiConverterString.allocationSize(inner[0]);
+            size += FfiConverterString.allocationSize(inner[1]);
+            return size;
+          }
+        case CryptoErrorUniffi_Tags.Base58Error:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(10);
+            size += FfiConverterString.allocationSize(inner[0]);
+            return size;
+          }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Error type: SessionLogError
+
+// Enum: SessionLogError
+export let SessionLogError_Tags = /*#__PURE__*/function (SessionLogError_Tags) {
+  SessionLogError_Tags["CoJson"] = "CoJson";
+  SessionLogError_Tags["Serde"] = "Serde";
+  SessionLogError_Tags["Generic"] = "Generic";
+  SessionLogError_Tags["LockError"] = "LockError";
+  return SessionLogError_Tags;
+}({});
+export const SessionLogError = (() => {
+  class CoJson_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'SessionLogError';
+    tag = SessionLogError_Tags.CoJson;
+    constructor(v0) {
+      super('SessionLogError', 'CoJson');
+      this.inner = Object.freeze([v0]);
+    }
+    static new(v0) {
+      return new CoJson_(v0);
+    }
+    static instanceOf(obj) {
+      return obj.tag === SessionLogError_Tags.CoJson;
+    }
+    static hasInner(obj) {
+      return CoJson_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class Serde_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'SessionLogError';
+    tag = SessionLogError_Tags.Serde;
+    constructor(v0) {
+      super('SessionLogError', 'Serde');
+      this.inner = Object.freeze([v0]);
+    }
+    static new(v0) {
+      return new Serde_(v0);
+    }
+    static instanceOf(obj) {
+      return obj.tag === SessionLogError_Tags.Serde;
+    }
+    static hasInner(obj) {
+      return Serde_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class Generic_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'SessionLogError';
+    tag = SessionLogError_Tags.Generic;
+    constructor(v0) {
+      super('SessionLogError', 'Generic');
+      this.inner = Object.freeze([v0]);
+    }
+    static new(v0) {
+      return new Generic_(v0);
+    }
+    static instanceOf(obj) {
+      return obj.tag === SessionLogError_Tags.Generic;
+    }
+    static hasInner(obj) {
+      return Generic_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class LockError_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = 'SessionLogError';
+    tag = SessionLogError_Tags.LockError;
+    constructor() {
+      super('SessionLogError', 'LockError');
+    }
+    static new() {
+      return new LockError_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === SessionLogError_Tags.LockError;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === 'SessionLogError';
+  }
+  return Object.freeze({
+    instanceOf,
+    CoJson: CoJson_,
+    Serde: Serde_,
+    Generic: Generic_,
+    LockError: LockError_
+  });
+})();
+// FfiConverter for enum SessionLogError
+const FfiConverterTypeSessionLogError = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new SessionLogError.CoJson(FfiConverterString.read(from));
+        case 2:
+          return new SessionLogError.Serde(FfiConverterString.read(from));
+        case 3:
+          return new SessionLogError.Generic(FfiConverterString.read(from));
+        case 4:
+          return new SessionLogError.LockError();
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value, into) {
+      switch (value.tag) {
+        case SessionLogError_Tags.CoJson:
+          {
+            ordinalConverter.write(1, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner[0], into);
+            return;
+          }
+        case SessionLogError_Tags.Serde:
+          {
+            ordinalConverter.write(2, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner[0], into);
+            return;
+          }
+        case SessionLogError_Tags.Generic:
+          {
+            ordinalConverter.write(3, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner[0], into);
+            return;
+          }
+        case SessionLogError_Tags.LockError:
+          {
+            ordinalConverter.write(4, into);
+            return;
+          }
+        default:
+          // Throwing from here means that SessionLogError_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case SessionLogError_Tags.CoJson:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(1);
+            size += FfiConverterString.allocationSize(inner[0]);
+            return size;
+          }
+        case SessionLogError_Tags.Serde:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(2);
+            size += FfiConverterString.allocationSize(inner[0]);
+            return size;
+          }
+        case SessionLogError_Tags.Generic:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(3);
+            size += FfiConverterString.allocationSize(inner[0]);
+            return size;
+          }
+        case SessionLogError_Tags.LockError:
+          {
+            return ordinalConverter.allocationSize(4);
+          }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+export class Blake3Hasher extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = 'Blake3Hasher';
+  constructor() {
+    super();
+    const pointer = uniffiCaller.rustCall(/*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_cojson_core_rn_fn_constructor_blake3hasher_new(callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeBlake3HasherObjectFactory.bless(pointer);
+  }
+  cloneHasher() /*throws*/{
+    return FfiConverterTypeBlake3Hasher.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBlake3Error.lift.bind(FfiConverterTypeBlake3Error), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_cojson_core_rn_fn_method_blake3hasher_clone_hasher(uniffiTypeBlake3HasherObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  finalize() /*throws*/{
+    return FfiConverterArrayBuffer.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBlake3Error.lift.bind(FfiConverterTypeBlake3Error), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_cojson_core_rn_fn_method_blake3hasher_finalize(uniffiTypeBlake3HasherObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  update(data) /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBlake3Error.lift.bind(FfiConverterTypeBlake3Error), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_cojson_core_rn_fn_method_blake3hasher_update(uniffiTypeBlake3HasherObjectFactory.clonePointer(this), FfiConverterArrayBuffer.lower(data), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeBlake3HasherObjectFactory.pointer(this);
+      uniffiTypeBlake3HasherObjectFactory.freePointer(pointer);
+      uniffiTypeBlake3HasherObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
+    }
+  }
+  static instanceOf(obj) {
+    return uniffiTypeBlake3HasherObjectFactory.isConcreteType(obj);
+  }
+}
+const uniffiTypeBlake3HasherObjectFactory = (() => {
+  return {
+    create(pointer) {
+      const instance = Object.create(Blake3Hasher.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = 'Blake3Hasher';
+      return instance;
+    },
+    bless(p) {
+      return uniffiCaller.rustCall(/*caller:*/status => nativeModule().ubrn_uniffi_internal_fn_method_blake3hasher_ffi__bless_pointer(p, status), /*liftString:*/FfiConverterString.lift);
+    },
+    unbless(ptr) {
+      ptr.markDestroyed();
+    },
+    pointer(obj) {
+      if (obj[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer();
+      }
+      return obj[pointerLiteralSymbol];
+    },
+    clonePointer(obj) {
+      const pointer = this.pointer(obj);
+      return uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_cojson_core_rn_fn_clone_blake3hasher(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_cojson_core_rn_fn_free_blake3hasher(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
+    },
+    isConcreteType(obj) {
+      return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Blake3Hasher';
+    }
+  };
+})();
+// FfiConverter for Blake3HasherInterface
+const FfiConverterTypeBlake3Hasher = new FfiConverterObject(uniffiTypeBlake3HasherObjectFactory);
+export class SessionLog extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = 'SessionLog';
+  constructor(coId, sessionId, signerId) {
+    super();
+    const pointer = uniffiCaller.rustCall(/*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_cojson_core_rn_fn_constructor_sessionlog_new(FfiConverterString.lower(coId), FfiConverterString.lower(sessionId), FfiConverterOptionalString.lower(signerId), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeSessionLogObjectFactory.bless(pointer);
+  }
+  addNewPrivateTransaction(changesJson, signerSecret, encryptionKey, keyId, madeAt, meta) /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeSessionLogError.lift.bind(FfiConverterTypeSessionLogError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_cojson_core_rn_fn_method_sessionlog_add_new_private_transaction(uniffiTypeSessionLogObjectFactory.clonePointer(this), FfiConverterString.lower(changesJson), FfiConverterString.lower(signerSecret), FfiConverterString.lower(encryptionKey), FfiConverterString.lower(keyId), FfiConverterFloat64.lower(madeAt), FfiConverterOptionalString.lower(meta), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  addNewTrustingTransaction(changesJson, signerSecret, madeAt, meta) /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeSessionLogError.lift.bind(FfiConverterTypeSessionLogError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_cojson_core_rn_fn_method_sessionlog_add_new_trusting_transaction(uniffiTypeSessionLogObjectFactory.clonePointer(this), FfiConverterString.lower(changesJson), FfiConverterString.lower(signerSecret), FfiConverterFloat64.lower(madeAt), FfiConverterOptionalString.lower(meta), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  cloneSessionLog() /*throws*/{
+    return FfiConverterTypeSessionLog.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeSessionLogError.lift.bind(FfiConverterTypeSessionLogError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_cojson_core_rn_fn_method_sessionlog_clone_session_log(uniffiTypeSessionLogObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  decryptNextTransactionChangesJson(txIndex, encryptionKey) /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeSessionLogError.lift.bind(FfiConverterTypeSessionLogError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_cojson_core_rn_fn_method_sessionlog_decrypt_next_transaction_changes_json(uniffiTypeSessionLogObjectFactory.clonePointer(this), FfiConverterUInt32.lower(txIndex), FfiConverterString.lower(encryptionKey), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  decryptNextTransactionMetaJson(txIndex, encryptionKey) /*throws*/{
+    return FfiConverterOptionalString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeSessionLogError.lift.bind(FfiConverterTypeSessionLogError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_cojson_core_rn_fn_method_sessionlog_decrypt_next_transaction_meta_json(uniffiTypeSessionLogObjectFactory.clonePointer(this), FfiConverterUInt32.lower(txIndex), FfiConverterString.lower(encryptionKey), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  tryAdd(transactionsJson, newSignatureStr, skipVerify) /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeSessionLogError.lift.bind(FfiConverterTypeSessionLogError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_cojson_core_rn_fn_method_sessionlog_try_add(uniffiTypeSessionLogObjectFactory.clonePointer(this), FfiConverterArrayString.lower(transactionsJson), FfiConverterString.lower(newSignatureStr), FfiConverterBool.lower(skipVerify), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeSessionLogObjectFactory.pointer(this);
+      uniffiTypeSessionLogObjectFactory.freePointer(pointer);
+      uniffiTypeSessionLogObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
+    }
+  }
+  static instanceOf(obj) {
+    return uniffiTypeSessionLogObjectFactory.isConcreteType(obj);
+  }
+}
+const uniffiTypeSessionLogObjectFactory = (() => {
+  return {
+    create(pointer) {
+      const instance = Object.create(SessionLog.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = 'SessionLog';
+      return instance;
+    },
+    bless(p) {
+      return uniffiCaller.rustCall(/*caller:*/status => nativeModule().ubrn_uniffi_internal_fn_method_sessionlog_ffi__bless_pointer(p, status), /*liftString:*/FfiConverterString.lift);
+    },
+    unbless(ptr) {
+      ptr.markDestroyed();
+    },
+    pointer(obj) {
+      if (obj[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer();
+      }
+      return obj[pointerLiteralSymbol];
+    },
+    clonePointer(obj) {
+      const pointer = this.pointer(obj);
+      return uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_cojson_core_rn_fn_clone_sessionlog(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_cojson_core_rn_fn_free_sessionlog(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
+    },
+    isConcreteType(obj) {
+      return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'SessionLog';
+    }
+  };
+})();
+// FfiConverter for SessionLogInterface
+const FfiConverterTypeSessionLog = new FfiConverterObject(uniffiTypeSessionLogObjectFactory);
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+// FfiConverter for Array<string>
+const FfiConverterArrayString = new FfiConverterArray(FfiConverterString);
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+  // Get the bindings contract version from our ComponentInterface
+  const bindingsContractVersion = 29;
+  // Get the scaffolding contract version by calling the into the dylib
+  const scaffoldingContractVersion = nativeModule().ubrn_ffi_cojson_core_rn_uniffi_contract_version();
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_blake3_hash_once() !== 58834) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_blake3_hash_once');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_blake3_hash_once_with_context() !== 28201) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_blake3_hash_once_with_context');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_decrypt() !== 5223) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_decrypt');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_decrypt_xsalsa20() !== 29059) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_decrypt_xsalsa20');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_ed25519_sign() !== 5643) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_ed25519_sign');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_ed25519_signature_from_bytes() !== 4624) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_ed25519_signature_from_bytes');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_ed25519_signing_key_from_bytes() !== 37961) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_ed25519_signing_key_from_bytes');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_ed25519_signing_key_sign() !== 50296) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_ed25519_signing_key_sign');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_ed25519_signing_key_to_public() !== 17719) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_ed25519_signing_key_to_public');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_ed25519_verify() !== 49484) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_ed25519_verify');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_ed25519_verifying_key() !== 63215) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_ed25519_verifying_key');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_ed25519_verifying_key_from_bytes() !== 42802) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_ed25519_verifying_key_from_bytes');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_encrypt() !== 552) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_encrypt');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_encrypt_xsalsa20() !== 29297) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_encrypt_xsalsa20');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_generate_nonce() !== 55335) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_generate_nonce');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_get_sealer_id() !== 35163) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_get_sealer_id');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_get_signer_id() !== 4067) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_get_signer_id');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_new_ed25519_signing_key() !== 3282) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_new_ed25519_signing_key');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_new_x25519_private_key() !== 56777) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_new_x25519_private_key');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_seal() !== 48965) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_seal');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_sign() !== 12539) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_sign');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_unseal() !== 52356) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_unseal');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_verify() !== 59548) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_verify');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_x25519_diffie_hellman() !== 23336) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_x25519_diffie_hellman');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_func_x25519_public_key() !== 18915) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_func_x25519_public_key');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_method_blake3hasher_clone_hasher() !== 23778) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_method_blake3hasher_clone_hasher');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_method_blake3hasher_finalize() !== 64111) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_method_blake3hasher_finalize');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_method_blake3hasher_update() !== 27902) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_method_blake3hasher_update');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_method_sessionlog_add_new_private_transaction() !== 3753) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_method_sessionlog_add_new_private_transaction');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_method_sessionlog_add_new_trusting_transaction() !== 43511) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_method_sessionlog_add_new_trusting_transaction');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_method_sessionlog_clone_session_log() !== 8261) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_method_sessionlog_clone_session_log');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_method_sessionlog_decrypt_next_transaction_changes_json() !== 22072) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_method_sessionlog_decrypt_next_transaction_changes_json');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_method_sessionlog_decrypt_next_transaction_meta_json() !== 5632) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_method_sessionlog_decrypt_next_transaction_meta_json');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_method_sessionlog_try_add() !== 21226) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_method_sessionlog_try_add');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_constructor_blake3hasher_new() !== 24312) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_constructor_blake3hasher_new');
+  }
+  if (nativeModule().ubrn_uniffi_cojson_core_rn_checksum_constructor_sessionlog_new() !== 25716) {
+    throw new UniffiInternalError.ApiChecksumMismatch('uniffi_cojson_core_rn_checksum_constructor_sessionlog_new');
+  }
+}
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeBlake3Error,
+    FfiConverterTypeBlake3Hasher,
+    FfiConverterTypeCryptoErrorUniffi,
+    FfiConverterTypeSessionLog,
+    FfiConverterTypeSessionLogError
+  }
+});
+//# sourceMappingURL=cojson_core_rn.js.map