jazz-rn 2.0.0-alpha.6

package/src/generated/jazz_rn.ts

@@ -0,0 +1,1391 @@
+// 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, {
+  type UniffiRustFutureContinuationCallback,
+  type UniffiForeignFuture,
+  type UniffiForeignFutureStructU8,
+  type UniffiForeignFutureCompleteU8,
+  type UniffiForeignFutureStructI8,
+  type UniffiForeignFutureCompleteI8,
+  type UniffiForeignFutureStructU16,
+  type UniffiForeignFutureCompleteU16,
+  type UniffiForeignFutureStructI16,
+  type UniffiForeignFutureCompleteI16,
+  type UniffiForeignFutureStructU32,
+  type UniffiForeignFutureCompleteU32,
+  type UniffiForeignFutureStructI32,
+  type UniffiForeignFutureCompleteI32,
+  type UniffiForeignFutureStructU64,
+  type UniffiForeignFutureCompleteU64,
+  type UniffiForeignFutureStructI64,
+  type UniffiForeignFutureCompleteI64,
+  type UniffiForeignFutureStructF32,
+  type UniffiForeignFutureCompleteF32,
+  type UniffiForeignFutureStructF64,
+  type UniffiForeignFutureCompleteF64,
+  type UniffiForeignFutureStructPointer,
+  type UniffiForeignFutureCompletePointer,
+  type UniffiForeignFutureStructRustBuffer,
+  type UniffiForeignFutureCompleteRustBuffer,
+  type UniffiForeignFutureStructVoid,
+  type UniffiForeignFutureCompleteVoid,
+  type UniffiVTableCallbackInterfaceBatchedTickCallback,
+  type UniffiVTableCallbackInterfaceSubscriptionCallback,
+  type UniffiVTableCallbackInterfaceSyncMessageCallback,
+} from './jazz_rn-ffi';
+import {
+  type FfiConverter,
+  type UniffiByteArray,
+  type UniffiHandle,
+  type UniffiObjectFactory,
+  type UniffiReferenceHolder,
+  type UniffiRustArcPtr,
+  type UniffiRustCallStatus,
+  type UnsafeMutableRawPointer,
+  AbstractFfiConverterByteArray,
+  FfiConverterBool,
+  FfiConverterCallback,
+  FfiConverterInt32,
+  FfiConverterInt64,
+  FfiConverterObject,
+  FfiConverterOptional,
+  FfiConverterUInt64,
+  RustBuffer,
+  UniffiAbstractObject,
+  UniffiError,
+  UniffiInternalError,
+  UniffiResult,
+  UniffiRustCaller,
+  destructorGuardSymbol,
+  pointerLiteralSymbol,
+  uniffiCreateFfiConverterString,
+  uniffiTraitInterfaceCall,
+  uniffiTypeNameSymbol,
+  variantOrdinalSymbol,
+} 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.
+
+export function currentTimestampMs(): /*i64*/ bigint {
+  return FfiConverterInt64.lift(
+    uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_jazz_rn_fn_func_current_timestamp_ms(
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    )
+  );
+}
+export function generateId(): string {
+  return FfiConverterString.lift(
+    uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_jazz_rn_fn_func_generate_id(
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    )
+  );
+}
+
+export interface BatchedTickCallback {
+  /**
+   * Called by Rust when it wants JS to call `runtime.batched_tick()`.
+   */
+  requestBatchedTick(): void;
+}
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceBatchedTickCallback: {
+  vtable: UniffiVTableCallbackInterfaceBatchedTickCallback;
+  register: () => void;
+} = {
+  // Create the VTable using a series of closures.
+  // ts automatically converts these into C callback functions.
+  vtable: {
+    requestBatchedTick: (uniffiHandle: bigint) => {
+      const uniffiMakeCall = (): void => {
+        const jsCallback =
+          FfiConverterTypeBatchedTickCallback.lift(uniffiHandle);
+        return jsCallback.requestBatchedTick();
+      };
+      const uniffiResult = UniffiResult.ready<void>();
+      const uniffiHandleSuccess = (obj: any) => {};
+      const uniffiHandleError = (code: number, errBuf: UniffiByteArray) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCall(
+        /*makeCall:*/ uniffiMakeCall,
+        /*handleSuccess:*/ uniffiHandleSuccess,
+        /*handleError:*/ uniffiHandleError,
+        /*lowerString:*/ FfiConverterString.lower
+      );
+      return uniffiResult;
+    },
+    uniffiFree: (uniffiHandle: UniffiHandle): void => {
+      // BatchedTickCallback: this will throw a stale handle error if the handle isn't found.
+      FfiConverterTypeBatchedTickCallback.drop(uniffiHandle);
+    },
+  },
+  register: () => {
+    nativeModule().ubrn_uniffi_jazz_rn_fn_init_callback_vtable_batchedtickcallback(
+      uniffiCallbackInterfaceBatchedTickCallback.vtable
+    );
+  },
+};
+
+// FfiConverter protocol for callback interfaces
+const FfiConverterTypeBatchedTickCallback =
+  new FfiConverterCallback<BatchedTickCallback>();
+
+export interface SubscriptionCallback {
+  /**
+   * Called when a subscription produces an update.
+   */
+  onUpdate(deltaJson: string): void;
+}
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceSubscriptionCallback: {
+  vtable: UniffiVTableCallbackInterfaceSubscriptionCallback;
+  register: () => void;
+} = {
+  // Create the VTable using a series of closures.
+  // ts automatically converts these into C callback functions.
+  vtable: {
+    onUpdate: (uniffiHandle: bigint, deltaJson: Uint8Array) => {
+      const uniffiMakeCall = (): void => {
+        const jsCallback =
+          FfiConverterTypeSubscriptionCallback.lift(uniffiHandle);
+        return jsCallback.onUpdate(FfiConverterString.lift(deltaJson));
+      };
+      const uniffiResult = UniffiResult.ready<void>();
+      const uniffiHandleSuccess = (obj: any) => {};
+      const uniffiHandleError = (code: number, errBuf: UniffiByteArray) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCall(
+        /*makeCall:*/ uniffiMakeCall,
+        /*handleSuccess:*/ uniffiHandleSuccess,
+        /*handleError:*/ uniffiHandleError,
+        /*lowerString:*/ FfiConverterString.lower
+      );
+      return uniffiResult;
+    },
+    uniffiFree: (uniffiHandle: UniffiHandle): void => {
+      // SubscriptionCallback: this will throw a stale handle error if the handle isn't found.
+      FfiConverterTypeSubscriptionCallback.drop(uniffiHandle);
+    },
+  },
+  register: () => {
+    nativeModule().ubrn_uniffi_jazz_rn_fn_init_callback_vtable_subscriptioncallback(
+      uniffiCallbackInterfaceSubscriptionCallback.vtable
+    );
+  },
+};
+
+// FfiConverter protocol for callback interfaces
+const FfiConverterTypeSubscriptionCallback =
+  new FfiConverterCallback<SubscriptionCallback>();
+
+export interface SyncMessageCallback {
+  /**
+   * Called by Rust when it has an outbox message to send.
+   */
+  onSyncMessage(messageJson: string): void;
+}
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceSyncMessageCallback: {
+  vtable: UniffiVTableCallbackInterfaceSyncMessageCallback;
+  register: () => void;
+} = {
+  // Create the VTable using a series of closures.
+  // ts automatically converts these into C callback functions.
+  vtable: {
+    onSyncMessage: (uniffiHandle: bigint, messageJson: Uint8Array) => {
+      const uniffiMakeCall = (): void => {
+        const jsCallback =
+          FfiConverterTypeSyncMessageCallback.lift(uniffiHandle);
+        return jsCallback.onSyncMessage(FfiConverterString.lift(messageJson));
+      };
+      const uniffiResult = UniffiResult.ready<void>();
+      const uniffiHandleSuccess = (obj: any) => {};
+      const uniffiHandleError = (code: number, errBuf: UniffiByteArray) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCall(
+        /*makeCall:*/ uniffiMakeCall,
+        /*handleSuccess:*/ uniffiHandleSuccess,
+        /*handleError:*/ uniffiHandleError,
+        /*lowerString:*/ FfiConverterString.lower
+      );
+      return uniffiResult;
+    },
+    uniffiFree: (uniffiHandle: UniffiHandle): void => {
+      // SyncMessageCallback: this will throw a stale handle error if the handle isn't found.
+      FfiConverterTypeSyncMessageCallback.drop(uniffiHandle);
+    },
+  },
+  register: () => {
+    nativeModule().ubrn_uniffi_jazz_rn_fn_init_callback_vtable_syncmessagecallback(
+      uniffiCallbackInterfaceSyncMessageCallback.vtable
+    );
+  },
+};
+
+// FfiConverter protocol for callback interfaces
+const FfiConverterTypeSyncMessageCallback =
+  new FfiConverterCallback<SyncMessageCallback>();
+
+const stringConverter = {
+  stringToBytes: (s: string) =>
+    uniffiCaller.rustCall((status) =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_arraybuffer(
+        s,
+        status
+      )
+    ),
+  bytesToString: (ab: UniffiByteArray) =>
+    uniffiCaller.rustCall((status) =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__arraybuffer_to_string(
+        ab,
+        status
+      )
+    ),
+  stringByteLength: (s: string) =>
+    uniffiCaller.rustCall((status) =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(
+        s,
+        status
+      )
+    ),
+};
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+// Error type: JazzRnError
+
+// Enum: JazzRnError
+export enum JazzRnError_Tags {
+  InvalidJson = 'InvalidJson',
+  InvalidUuid = 'InvalidUuid',
+  InvalidTier = 'InvalidTier',
+  Schema = 'Schema',
+  Runtime = 'Runtime',
+  Internal = 'Internal',
+}
+export const JazzRnError = (() => {
+  type InvalidJson__interface = {
+    tag: JazzRnError_Tags.InvalidJson;
+    inner: Readonly<{ message: string }>;
+  };
+
+  class InvalidJson_ extends UniffiError implements InvalidJson__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'JazzRnError';
+    readonly tag = JazzRnError_Tags.InvalidJson;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('JazzRnError', 'InvalidJson');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { message: string }): InvalidJson_ {
+      return new InvalidJson_(inner);
+    }
+
+    static instanceOf(obj: any): obj is InvalidJson_ {
+      return obj.tag === JazzRnError_Tags.InvalidJson;
+    }
+
+    static hasInner(obj: any): obj is InvalidJson_ {
+      return InvalidJson_.instanceOf(obj);
+    }
+
+    static getInner(obj: InvalidJson_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type InvalidUuid__interface = {
+    tag: JazzRnError_Tags.InvalidUuid;
+    inner: Readonly<{ message: string }>;
+  };
+
+  class InvalidUuid_ extends UniffiError implements InvalidUuid__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'JazzRnError';
+    readonly tag = JazzRnError_Tags.InvalidUuid;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('JazzRnError', 'InvalidUuid');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { message: string }): InvalidUuid_ {
+      return new InvalidUuid_(inner);
+    }
+
+    static instanceOf(obj: any): obj is InvalidUuid_ {
+      return obj.tag === JazzRnError_Tags.InvalidUuid;
+    }
+
+    static hasInner(obj: any): obj is InvalidUuid_ {
+      return InvalidUuid_.instanceOf(obj);
+    }
+
+    static getInner(obj: InvalidUuid_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type InvalidTier__interface = {
+    tag: JazzRnError_Tags.InvalidTier;
+    inner: Readonly<{ message: string }>;
+  };
+
+  class InvalidTier_ extends UniffiError implements InvalidTier__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'JazzRnError';
+    readonly tag = JazzRnError_Tags.InvalidTier;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('JazzRnError', 'InvalidTier');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { message: string }): InvalidTier_ {
+      return new InvalidTier_(inner);
+    }
+
+    static instanceOf(obj: any): obj is InvalidTier_ {
+      return obj.tag === JazzRnError_Tags.InvalidTier;
+    }
+
+    static hasInner(obj: any): obj is InvalidTier_ {
+      return InvalidTier_.instanceOf(obj);
+    }
+
+    static getInner(obj: InvalidTier_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type Schema__interface = {
+    tag: JazzRnError_Tags.Schema;
+    inner: Readonly<{ message: string }>;
+  };
+
+  class Schema_ extends UniffiError implements Schema__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'JazzRnError';
+    readonly tag = JazzRnError_Tags.Schema;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('JazzRnError', 'Schema');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { message: string }): Schema_ {
+      return new Schema_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Schema_ {
+      return obj.tag === JazzRnError_Tags.Schema;
+    }
+
+    static hasInner(obj: any): obj is Schema_ {
+      return Schema_.instanceOf(obj);
+    }
+
+    static getInner(obj: Schema_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type Runtime__interface = {
+    tag: JazzRnError_Tags.Runtime;
+    inner: Readonly<{ message: string }>;
+  };
+
+  class Runtime_ extends UniffiError implements Runtime__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'JazzRnError';
+    readonly tag = JazzRnError_Tags.Runtime;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('JazzRnError', 'Runtime');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { message: string }): Runtime_ {
+      return new Runtime_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Runtime_ {
+      return obj.tag === JazzRnError_Tags.Runtime;
+    }
+
+    static hasInner(obj: any): obj is Runtime_ {
+      return Runtime_.instanceOf(obj);
+    }
+
+    static getInner(obj: Runtime_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  type Internal__interface = {
+    tag: JazzRnError_Tags.Internal;
+    inner: Readonly<{ message: string }>;
+  };
+
+  class Internal_ extends UniffiError implements Internal__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'JazzRnError';
+    readonly tag = JazzRnError_Tags.Internal;
+    readonly inner: Readonly<{ message: string }>;
+    constructor(inner: { message: string }) {
+      super('JazzRnError', 'Internal');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { message: string }): Internal_ {
+      return new Internal_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Internal_ {
+      return obj.tag === JazzRnError_Tags.Internal;
+    }
+
+    static hasInner(obj: any): obj is Internal_ {
+      return Internal_.instanceOf(obj);
+    }
+
+    static getInner(obj: Internal_): Readonly<{ message: string }> {
+      return obj.inner;
+    }
+  }
+
+  function instanceOf(obj: any): obj is JazzRnError {
+    return obj[uniffiTypeNameSymbol] === 'JazzRnError';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    InvalidJson: InvalidJson_,
+    InvalidUuid: InvalidUuid_,
+    InvalidTier: InvalidTier_,
+    Schema: Schema_,
+    Runtime: Runtime_,
+    Internal: Internal_,
+  });
+})();
+
+export type JazzRnError = InstanceType<
+  (typeof JazzRnError)[keyof Omit<typeof JazzRnError, 'instanceOf'>]
+>;
+
+// FfiConverter for enum JazzRnError
+const FfiConverterTypeJazzRnError = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = JazzRnError;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new JazzRnError.InvalidJson({
+            message: FfiConverterString.read(from),
+          });
+        case 2:
+          return new JazzRnError.InvalidUuid({
+            message: FfiConverterString.read(from),
+          });
+        case 3:
+          return new JazzRnError.InvalidTier({
+            message: FfiConverterString.read(from),
+          });
+        case 4:
+          return new JazzRnError.Schema({
+            message: FfiConverterString.read(from),
+          });
+        case 5:
+          return new JazzRnError.Runtime({
+            message: FfiConverterString.read(from),
+          });
+        case 6:
+          return new JazzRnError.Internal({
+            message: FfiConverterString.read(from),
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case JazzRnError_Tags.InvalidJson: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case JazzRnError_Tags.InvalidUuid: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case JazzRnError_Tags.InvalidTier: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case JazzRnError_Tags.Schema: {
+          ordinalConverter.write(4, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case JazzRnError_Tags.Runtime: {
+          ordinalConverter.write(5, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        case JazzRnError_Tags.Internal: {
+          ordinalConverter.write(6, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.message, into);
+          return;
+        }
+        default:
+          // Throwing from here means that JazzRnError_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case JazzRnError_Tags.InvalidJson: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case JazzRnError_Tags.InvalidUuid: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case JazzRnError_Tags.InvalidTier: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case JazzRnError_Tags.Schema: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(4);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case JazzRnError_Tags.Runtime: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(5);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        case JazzRnError_Tags.Internal: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(6);
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+export interface RnRuntimeInterface {
+  addClient() /*throws*/ : string;
+  addServer() /*throws*/ : void;
+  /**
+   * Run a batched tick. JS should call this when asked via `on_batched_tick_needed`.
+   */
+  batchedTick() /*throws*/ : void;
+  /**
+   * Flush and close the underlying storage, releasing filesystem locks.
+   */
+  close() /*throws*/ : void;
+  delete_(objectId: string) /*throws*/ : void;
+  flush() /*throws*/ : void;
+  getSchemaHash() /*throws*/ : string;
+  insert(table: string, valuesJson: string) /*throws*/ : string;
+  /**
+   * Register a JS callback that schedules `batched_tick()` calls.
+   */
+  onBatchedTickNeeded(
+    callback: BatchedTickCallback | undefined
+  ) /*throws*/ : void;
+  onSyncMessageReceived(messageJson: string) /*throws*/ : void;
+  onSyncMessageReceivedFromClient(
+    clientId: string,
+    messageJson: string
+  ) /*throws*/ : void;
+  /**
+   * Register a JS callback for outbound sync messages.
+   */
+  onSyncMessageToSend(
+    callback: SyncMessageCallback | undefined
+  ) /*throws*/ : void;
+  /**
+   * One-shot query returning a JSON string:
+   * `[{ "id": "<uuid>", "values": [ {type, value}, ... ] }, ...]`.
+   */
+  query(
+    queryJson: string,
+    sessionJson: string | undefined,
+    settledTier: string | undefined
+  ) /*throws*/ : string;
+  removeServer() /*throws*/ : void;
+  setClientRole(clientId: string, role: string) /*throws*/ : void;
+  subscribe(
+    queryJson: string,
+    callback: SubscriptionCallback,
+    sessionJson: string | undefined,
+    settledTier: string | undefined
+  ) /*throws*/ : /*u64*/ bigint;
+  unsubscribe(handle: /*u64*/ bigint) /*throws*/ : void;
+  update(objectId: string, valuesJson: string) /*throws*/ : void;
+}
+
+export class RnRuntime
+  extends UniffiAbstractObject
+  implements RnRuntimeInterface
+{
+  readonly [uniffiTypeNameSymbol] = 'RnRuntime';
+  readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+  readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+  constructor(
+    schemaJson: string,
+    appId: string,
+    jazzEnv: string,
+    userBranch: string,
+    tier: string | undefined,
+    dataPath: string | undefined
+  ) /*throws*/ {
+    super();
+    const pointer = uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_jazz_rn_fn_constructor_rnruntime_new(
+          FfiConverterString.lower(schemaJson),
+          FfiConverterString.lower(appId),
+          FfiConverterString.lower(jazzEnv),
+          FfiConverterString.lower(userBranch),
+          FfiConverterOptionalString.lower(tier),
+          FfiConverterOptionalString.lower(dataPath),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] =
+      uniffiTypeRnRuntimeObjectFactory.bless(pointer);
+  }
+
+  public addClient(): string /*throws*/ {
+    return FfiConverterString.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+          FfiConverterTypeJazzRnError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_add_client(
+            uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  public addServer(): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_add_server(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  /**
+   * Run a batched tick. JS should call this when asked via `on_batched_tick_needed`.
+   */
+  public batchedTick(): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_batched_tick(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  /**
+   * Flush and close the underlying storage, releasing filesystem locks.
+   */
+  public close(): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_close(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  public delete_(objectId: string): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_delete(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          FfiConverterString.lower(objectId),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  public flush(): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_flush(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  public getSchemaHash(): string /*throws*/ {
+    return FfiConverterString.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+          FfiConverterTypeJazzRnError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_get_schema_hash(
+            uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  public insert(table: string, valuesJson: string): string /*throws*/ {
+    return FfiConverterString.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+          FfiConverterTypeJazzRnError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_insert(
+            uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+            FfiConverterString.lower(table),
+            FfiConverterString.lower(valuesJson),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * Register a JS callback that schedules `batched_tick()` calls.
+   */
+  public onBatchedTickNeeded(
+    callback: BatchedTickCallback | undefined
+  ): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_on_batched_tick_needed(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          FfiConverterOptionalTypeBatchedTickCallback.lower(callback),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  public onSyncMessageReceived(messageJson: string): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_on_sync_message_received(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          FfiConverterString.lower(messageJson),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  public onSyncMessageReceivedFromClient(
+    clientId: string,
+    messageJson: string
+  ): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_on_sync_message_received_from_client(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          FfiConverterString.lower(clientId),
+          FfiConverterString.lower(messageJson),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  /**
+   * Register a JS callback for outbound sync messages.
+   */
+  public onSyncMessageToSend(
+    callback: SyncMessageCallback | undefined
+  ): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_on_sync_message_to_send(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          FfiConverterOptionalTypeSyncMessageCallback.lower(callback),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  /**
+   * One-shot query returning a JSON string:
+   * `[{ "id": "<uuid>", "values": [ {type, value}, ... ] }, ...]`.
+   */
+  public query(
+    queryJson: string,
+    sessionJson: string | undefined,
+    settledTier: string | undefined
+  ): string /*throws*/ {
+    return FfiConverterString.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+          FfiConverterTypeJazzRnError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_query(
+            uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+            FfiConverterString.lower(queryJson),
+            FfiConverterOptionalString.lower(sessionJson),
+            FfiConverterOptionalString.lower(settledTier),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  public removeServer(): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_remove_server(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  public setClientRole(clientId: string, role: string): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_set_client_role(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          FfiConverterString.lower(clientId),
+          FfiConverterString.lower(role),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  public subscribe(
+    queryJson: string,
+    callback: SubscriptionCallback,
+    sessionJson: string | undefined,
+    settledTier: string | undefined
+  ): /*u64*/ bigint /*throws*/ {
+    return FfiConverterUInt64.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+          FfiConverterTypeJazzRnError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_subscribe(
+            uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+            FfiConverterString.lower(queryJson),
+            FfiConverterTypeSubscriptionCallback.lower(callback),
+            FfiConverterOptionalString.lower(sessionJson),
+            FfiConverterOptionalString.lower(settledTier),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  public unsubscribe(handle: /*u64*/ bigint): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_unsubscribe(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          FfiConverterUInt64.lower(handle),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  public update(objectId: string, valuesJson: string): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeJazzRnError.lift.bind(
+        FfiConverterTypeJazzRnError
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_jazz_rn_fn_method_rnruntime_update(
+          uniffiTypeRnRuntimeObjectFactory.clonePointer(this),
+          FfiConverterString.lower(objectId),
+          FfiConverterString.lower(valuesJson),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeRnRuntimeObjectFactory.pointer(this);
+      uniffiTypeRnRuntimeObjectFactory.freePointer(pointer);
+      uniffiTypeRnRuntimeObjectFactory.unbless(ptr);
+      delete (this as any)[destructorGuardSymbol];
+    }
+  }
+
+  static instanceOf(obj: any): obj is RnRuntime {
+    return uniffiTypeRnRuntimeObjectFactory.isConcreteType(obj);
+  }
+}
+
+const uniffiTypeRnRuntimeObjectFactory: UniffiObjectFactory<RnRuntimeInterface> =
+  (() => {
+    return {
+      create(pointer: UnsafeMutableRawPointer): RnRuntimeInterface {
+        const instance = Object.create(RnRuntime.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = 'RnRuntime';
+        return instance;
+      },
+
+      bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr {
+        return uniffiCaller.rustCall(
+          /*caller:*/ (status) =>
+            nativeModule().ubrn_uniffi_internal_fn_method_rnruntime_ffi__bless_pointer(
+              p,
+              status
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      unbless(ptr: UniffiRustArcPtr) {
+        ptr.markDestroyed();
+      },
+
+      pointer(obj: RnRuntimeInterface): UnsafeMutableRawPointer {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+          throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+      },
+
+      clonePointer(obj: RnRuntimeInterface): UnsafeMutableRawPointer {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_jazz_rn_fn_clone_rnruntime(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      freePointer(pointer: UnsafeMutableRawPointer): void {
+        uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_jazz_rn_fn_free_rnruntime(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      isConcreteType(obj: any): obj is RnRuntimeInterface {
+        return (
+          obj[destructorGuardSymbol] &&
+          obj[uniffiTypeNameSymbol] === 'RnRuntime'
+        );
+      },
+    };
+  })();
+// FfiConverter for RnRuntimeInterface
+const FfiConverterTypeRnRuntime = new FfiConverterObject(
+  uniffiTypeRnRuntimeObjectFactory
+);
+
+// FfiConverter for BatchedTickCallback | undefined
+const FfiConverterOptionalTypeBatchedTickCallback = new FfiConverterOptional(
+  FfiConverterTypeBatchedTickCallback
+);
+
+// FfiConverter for SyncMessageCallback | undefined
+const FfiConverterOptionalTypeSyncMessageCallback = new FfiConverterOptional(
+  FfiConverterTypeSyncMessageCallback
+);
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(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_jazz_rn_uniffi_contract_version();
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(
+      scaffoldingContractVersion,
+      bindingsContractVersion
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_func_current_timestamp_ms() !==
+    20765
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_func_current_timestamp_ms'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_func_generate_id() !== 58723
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_func_generate_id'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_add_client() !==
+    20251
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_add_client'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_add_server() !==
+    28260
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_add_server'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_batched_tick() !==
+    23711
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_batched_tick'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_close() !==
+    17169
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_close'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_delete() !==
+    4621
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_delete'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_flush() !==
+    62556
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_flush'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_get_schema_hash() !==
+    39147
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_get_schema_hash'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_insert() !==
+    12677
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_insert'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_on_batched_tick_needed() !==
+    36428
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_on_batched_tick_needed'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_on_sync_message_received() !==
+    57227
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_on_sync_message_received'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_on_sync_message_received_from_client() !==
+    32020
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_on_sync_message_received_from_client'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_on_sync_message_to_send() !==
+    58836
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_on_sync_message_to_send'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_query() !==
+    33623
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_query'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_remove_server() !==
+    7238
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_remove_server'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_set_client_role() !==
+    4241
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_set_client_role'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_subscribe() !==
+    24615
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_subscribe'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_unsubscribe() !==
+    22724
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_unsubscribe'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_rnruntime_update() !==
+    52169
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_rnruntime_update'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_constructor_rnruntime_new() !==
+    5640
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_constructor_rnruntime_new'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_batchedtickcallback_request_batched_tick() !==
+    53765
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_batchedtickcallback_request_batched_tick'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_subscriptioncallback_on_update() !==
+    5131
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_subscriptioncallback_on_update'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_jazz_rn_checksum_method_syncmessagecallback_on_sync_message() !==
+    26254
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_jazz_rn_checksum_method_syncmessagecallback_on_sync_message'
+    );
+  }
+
+  uniffiCallbackInterfaceBatchedTickCallback.register();
+  uniffiCallbackInterfaceSubscriptionCallback.register();
+  uniffiCallbackInterfaceSyncMessageCallback.register();
+}
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeJazzRnError,
+    FfiConverterTypeRnRuntime,
+  },
+});