cojson-core-rn 0.19.10

package/lib/typescript/src/generated/cojson_core_rn.d.ts

@@ -0,0 +1,1299 @@
+import { type UniffiByteArray, type UniffiRustArcPtr, type UnsafeMutableRawPointer, FfiConverterObject, RustBuffer, UniffiAbstractObject, destructorGuardSymbol, pointerLiteralSymbol, uniffiTypeNameSymbol } from 'uniffi-bindgen-react-native';
+/**
+ * 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 declare function blake3HashOnce(data: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function blake3HashOnceWithContext(data: ArrayBuffer, context: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function decrypt(ciphertext: ArrayBuffer, keySecret: string, nonceMaterial: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function decryptXsalsa20(key: ArrayBuffer, nonceMaterial: ArrayBuffer, ciphertext: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function ed25519Sign(signingKey: ArrayBuffer, message: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function ed25519SignatureFromBytes(bytes: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function ed25519SigningKeyFromBytes(bytes: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function ed25519SigningKeySign(signingKey: ArrayBuffer, message: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function ed25519SigningKeyToPublic(signingKey: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function ed25519Verify(verifyingKey: ArrayBuffer, message: ArrayBuffer, signature: ArrayBuffer): boolean;
+/**
+ * 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 declare function ed25519VerifyingKey(signingKey: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function ed25519VerifyingKeyFromBytes(bytes: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function encrypt(value: ArrayBuffer, keySecret: string, nonceMaterial: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function encryptXsalsa20(key: ArrayBuffer, nonceMaterial: ArrayBuffer, plaintext: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function generateNonce(nonceMaterial: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function getSealerId(secret: string): string;
+/**
+ * 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 declare function getSignerId(secret: string): string;
+/**
+ * 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 declare function newEd25519SigningKey(): ArrayBuffer;
+/**
+ * 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 declare function newX25519PrivateKey(): ArrayBuffer;
+/**
+ * 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 declare function seal(message: ArrayBuffer, senderSecret: string, recipientId: string, nonceMaterial: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function sign(message: ArrayBuffer, secret: string): string;
+/**
+ * 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 declare function unseal(sealedMessage: ArrayBuffer, recipientSecret: string, senderId: string, nonceMaterial: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function verify(signature: string, message: ArrayBuffer, id: string): boolean;
+/**
+ * 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 declare function x25519DiffieHellman(privateKey: ArrayBuffer, publicKey: ArrayBuffer): ArrayBuffer;
+/**
+ * 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 declare function x25519PublicKey(privateKey: ArrayBuffer): ArrayBuffer;
+export declare enum Blake3Error_Tags {
+    LockError = "LockError"
+}
+export declare const Blake3Error: Readonly<{
+    instanceOf: (obj: any) => obj is Blake3Error;
+    LockError: {
+        new (): {
+            readonly tag: Blake3Error_Tags.LockError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "Blake3Error";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            readonly tag: Blake3Error_Tags.LockError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "Blake3Error";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: Blake3Error_Tags.LockError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "Blake3Error";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: Blake3Error_Tags.LockError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "Blake3Error";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}>;
+export type Blake3Error = InstanceType<(typeof Blake3Error)[keyof Omit<typeof Blake3Error, 'instanceOf'>]>;
+export declare enum CryptoErrorUniffi_Tags {
+    InvalidKeyLength = "InvalidKeyLength",
+    InvalidNonceLength = "InvalidNonceLength",
+    InvalidSealerSecretFormat = "InvalidSealerSecretFormat",
+    InvalidSignatureLength = "InvalidSignatureLength",
+    InvalidVerifyingKey = "InvalidVerifyingKey",
+    InvalidPublicKey = "InvalidPublicKey",
+    WrongTag = "WrongTag",
+    CipherError = "CipherError",
+    InvalidPrefix = "InvalidPrefix",
+    Base58Error = "Base58Error"
+}
+export declare const CryptoErrorUniffi: Readonly<{
+    instanceOf: (obj: any) => obj is CryptoErrorUniffi;
+    InvalidKeyLength: {
+        new (v0: bigint, v1: bigint): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidKeyLength;
+            readonly inner: Readonly<[/*u64*/ bigint, /*u64*/ bigint]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: bigint, v1: bigint): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidKeyLength;
+            readonly inner: Readonly<[/*u64*/ bigint, /*u64*/ bigint]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidKeyLength;
+            readonly inner: Readonly<[/*u64*/ bigint, /*u64*/ bigint]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidKeyLength;
+            readonly inner: Readonly<[/*u64*/ bigint, /*u64*/ bigint]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidKeyLength;
+            readonly inner: Readonly<[/*u64*/ bigint, /*u64*/ bigint]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[/*u64*/ bigint, /*u64*/ bigint]>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidNonceLength: {
+        new (): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidNonceLength;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidNonceLength;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidNonceLength;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidNonceLength;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidSealerSecretFormat: {
+        new (): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidSealerSecretFormat;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidSealerSecretFormat;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidSealerSecretFormat;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidSealerSecretFormat;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidSignatureLength: {
+        new (): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidSignatureLength;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidSignatureLength;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidSignatureLength;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidSignatureLength;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidVerifyingKey: {
+        new (v0: string): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidVerifyingKey;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidVerifyingKey;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidVerifyingKey;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidVerifyingKey;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidVerifyingKey;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidPublicKey: {
+        new (v0: string): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidPublicKey;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidPublicKey;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidPublicKey;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidPublicKey;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidPublicKey;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    WrongTag: {
+        new (): {
+            readonly tag: CryptoErrorUniffi_Tags.WrongTag;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            readonly tag: CryptoErrorUniffi_Tags.WrongTag;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.WrongTag;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.WrongTag;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    CipherError: {
+        new (): {
+            readonly tag: CryptoErrorUniffi_Tags.CipherError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            readonly tag: CryptoErrorUniffi_Tags.CipherError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.CipherError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.CipherError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidPrefix: {
+        new (v0: string, v1: string): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidPrefix;
+            readonly inner: Readonly<[string, string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string, v1: string): {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidPrefix;
+            readonly inner: Readonly<[string, string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidPrefix;
+            readonly inner: Readonly<[string, string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidPrefix;
+            readonly inner: Readonly<[string, string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: CryptoErrorUniffi_Tags.InvalidPrefix;
+            readonly inner: Readonly<[string, string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string, string]>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Base58Error: {
+        new (v0: string): {
+            readonly tag: CryptoErrorUniffi_Tags.Base58Error;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: CryptoErrorUniffi_Tags.Base58Error;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.Base58Error;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: CryptoErrorUniffi_Tags.Base58Error;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: CryptoErrorUniffi_Tags.Base58Error;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CryptoErrorUniffi";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}>;
+export type CryptoErrorUniffi = InstanceType<(typeof CryptoErrorUniffi)[keyof Omit<typeof CryptoErrorUniffi, 'instanceOf'>]>;
+export declare enum SessionLogError_Tags {
+    CoJson = "CoJson",
+    Serde = "Serde",
+    Generic = "Generic",
+    LockError = "LockError"
+}
+export declare const SessionLogError: Readonly<{
+    instanceOf: (obj: any) => obj is SessionLogError;
+    CoJson: {
+        new (v0: string): {
+            readonly tag: SessionLogError_Tags.CoJson;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: SessionLogError_Tags.CoJson;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SessionLogError_Tags.CoJson;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SessionLogError_Tags.CoJson;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SessionLogError_Tags.CoJson;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Serde: {
+        new (v0: string): {
+            readonly tag: SessionLogError_Tags.Serde;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: SessionLogError_Tags.Serde;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SessionLogError_Tags.Serde;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SessionLogError_Tags.Serde;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SessionLogError_Tags.Serde;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Generic: {
+        new (v0: string): {
+            readonly tag: SessionLogError_Tags.Generic;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: SessionLogError_Tags.Generic;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SessionLogError_Tags.Generic;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SessionLogError_Tags.Generic;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SessionLogError_Tags.Generic;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    LockError: {
+        new (): {
+            readonly tag: SessionLogError_Tags.LockError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            readonly tag: SessionLogError_Tags.LockError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SessionLogError_Tags.LockError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SessionLogError_Tags.LockError;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SessionLogError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}>;
+export type SessionLogError = InstanceType<(typeof SessionLogError)[keyof Omit<typeof SessionLogError, 'instanceOf'>]>;
+export interface Blake3HasherInterface {
+    cloneHasher(): Blake3HasherInterface;
+    finalize(): ArrayBuffer;
+    update(data: ArrayBuffer): void;
+}
+export declare class Blake3Hasher extends UniffiAbstractObject implements Blake3HasherInterface {
+    readonly [uniffiTypeNameSymbol] = "Blake3Hasher";
+    readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+    readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+    constructor();
+    cloneHasher(): Blake3HasherInterface;
+    finalize(): ArrayBuffer;
+    update(data: ArrayBuffer): void;
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void;
+    static instanceOf(obj: any): obj is Blake3Hasher;
+}
+export interface SessionLogInterface {
+    addNewPrivateTransaction(changesJson: string, signerSecret: string, encryptionKey: string, keyId: string, madeAt: number, meta: string | undefined): string;
+    addNewTrustingTransaction(changesJson: string, signerSecret: string, madeAt: number, meta: string | undefined): string;
+    cloneSessionLog(): SessionLogInterface;
+    decryptNextTransactionChangesJson(txIndex: number, encryptionKey: string): string;
+    decryptNextTransactionMetaJson(txIndex: number, encryptionKey: string): string | undefined;
+    tryAdd(transactionsJson: Array<string>, newSignatureStr: string, skipVerify: boolean): void;
+}
+export declare class SessionLog extends UniffiAbstractObject implements SessionLogInterface {
+    readonly [uniffiTypeNameSymbol] = "SessionLog";
+    readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+    readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+    constructor(coId: string, sessionId: string, signerId: string | undefined);
+    addNewPrivateTransaction(changesJson: string, signerSecret: string, encryptionKey: string, keyId: string, madeAt: number, meta: string | undefined): string;
+    addNewTrustingTransaction(changesJson: string, signerSecret: string, madeAt: number, meta: string | undefined): string;
+    cloneSessionLog(): SessionLogInterface;
+    decryptNextTransactionChangesJson(txIndex: number, encryptionKey: string): string;
+    decryptNextTransactionMetaJson(txIndex: number, encryptionKey: string): string | undefined;
+    tryAdd(transactionsJson: Array<string>, newSignatureStr: string, skipVerify: boolean): void;
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void;
+    static instanceOf(obj: any): obj is SessionLog;
+}
+/**
+ * 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.
+ */
+declare function uniffiEnsureInitialized(): void;
+declare const _default: Readonly<{
+    initialize: typeof uniffiEnsureInitialized;
+    converters: {
+        FfiConverterTypeBlake3Error: {
+            read(from: RustBuffer): {
+                readonly tag: Blake3Error_Tags.LockError;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "Blake3Error";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            write(value: {
+                readonly tag: Blake3Error_Tags.LockError;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "Blake3Error";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, into: RustBuffer): void;
+            allocationSize(value: {
+                readonly tag: Blake3Error_Tags.LockError;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "Blake3Error";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }): number;
+            lift(value: UniffiByteArray): {
+                readonly tag: Blake3Error_Tags.LockError;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "Blake3Error";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            lower(value: {
+                readonly tag: Blake3Error_Tags.LockError;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "Blake3Error";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }): UniffiByteArray;
+        };
+        FfiConverterTypeBlake3Hasher: FfiConverterObject<Blake3HasherInterface>;
+        FfiConverterTypeCryptoErrorUniffi: {
+            read(from: RustBuffer): CryptoErrorUniffi;
+            write(value: CryptoErrorUniffi, into: RustBuffer): void;
+            allocationSize(value: CryptoErrorUniffi): number;
+            lift(value: UniffiByteArray): CryptoErrorUniffi;
+            lower(value: CryptoErrorUniffi): UniffiByteArray;
+        };
+        FfiConverterTypeSessionLog: FfiConverterObject<SessionLogInterface>;
+        FfiConverterTypeSessionLogError: {
+            read(from: RustBuffer): SessionLogError;
+            write(value: SessionLogError, into: RustBuffer): void;
+            allocationSize(value: SessionLogError): number;
+            lift(value: UniffiByteArray): SessionLogError;
+            lower(value: SessionLogError): UniffiByteArray;
+        };
+    };
+}>;
+export default _default;
+//# sourceMappingURL=cojson_core_rn.d.ts.map