@secondts/bark-react-native 0.2.0-beta.1 → 0.3.0-beta.1

package/src/generated/bark.ts

@@ -55,6 +55,7 @@ import {
   FfiConverterUInt64,
   RustBuffer,
   UniffiAbstractObject,
+  UniffiEnum,
   UniffiError,
   UniffiInternalError,
   UniffiResult,
@@ -63,6 +64,7 @@ import {
   pointerLiteralSymbol,
   uniffiCreateFfiConverterString,
   uniffiCreateRecord,
+  uniffiRustCallAsync,
   uniffiTraitInterfaceCallWithError,
   uniffiTypeNameSymbol,
   variantOrdinalSymbol,
@@ -3265,6 +3267,422 @@ const FfiConverterTypeNetwork = (() => {
   return new FFIConverter();
 })();
 
+// Enum: WalletNotification
+export enum WalletNotification_Tags {
+  MovementCreated = "MovementCreated",
+  MovementUpdated = "MovementUpdated",
+  ChannelLagging = "ChannelLagging",
+}
+/**
+ * A notification event from the wallet
+ */
+export const WalletNotification = (() => {
+  type MovementCreated__interface = {
+    tag: WalletNotification_Tags.MovementCreated;
+    inner: Readonly<{ movement: Movement }>;
+  };
+
+  /**
+   * A new movement was created
+   */
+  class MovementCreated_
+    extends UniffiEnum
+    implements MovementCreated__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "WalletNotification";
+    readonly tag = WalletNotification_Tags.MovementCreated;
+    readonly inner: Readonly<{ movement: Movement }>;
+    constructor(inner: { movement: Movement }) {
+      super("WalletNotification", "MovementCreated");
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { movement: Movement }): MovementCreated_ {
+      return new MovementCreated_(inner);
+    }
+
+    static instanceOf(obj: any): obj is MovementCreated_ {
+      return obj.tag === WalletNotification_Tags.MovementCreated;
+    }
+  }
+
+  type MovementUpdated__interface = {
+    tag: WalletNotification_Tags.MovementUpdated;
+    inner: Readonly<{ movement: Movement }>;
+  };
+
+  /**
+   * An existing movement was updated
+   */
+  class MovementUpdated_
+    extends UniffiEnum
+    implements MovementUpdated__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "WalletNotification";
+    readonly tag = WalletNotification_Tags.MovementUpdated;
+    readonly inner: Readonly<{ movement: Movement }>;
+    constructor(inner: { movement: Movement }) {
+      super("WalletNotification", "MovementUpdated");
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { movement: Movement }): MovementUpdated_ {
+      return new MovementUpdated_(inner);
+    }
+
+    static instanceOf(obj: any): obj is MovementUpdated_ {
+      return obj.tag === WalletNotification_Tags.MovementUpdated;
+    }
+  }
+
+  type ChannelLagging__interface = {
+    tag: WalletNotification_Tags.ChannelLagging;
+  };
+
+  /**
+   * The notification channel is lagging (some notifications were dropped)
+   */
+  class ChannelLagging_
+    extends UniffiEnum
+    implements ChannelLagging__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "WalletNotification";
+    readonly tag = WalletNotification_Tags.ChannelLagging;
+    constructor() {
+      super("WalletNotification", "ChannelLagging");
+    }
+
+    static new(): ChannelLagging_ {
+      return new ChannelLagging_();
+    }
+
+    static instanceOf(obj: any): obj is ChannelLagging_ {
+      return obj.tag === WalletNotification_Tags.ChannelLagging;
+    }
+  }
+
+  function instanceOf(obj: any): obj is WalletNotification {
+    return obj[uniffiTypeNameSymbol] === "WalletNotification";
+  }
+
+  return Object.freeze({
+    instanceOf,
+    MovementCreated: MovementCreated_,
+    MovementUpdated: MovementUpdated_,
+    ChannelLagging: ChannelLagging_,
+  });
+})();
+
+/**
+ * A notification event from the wallet
+ */
+
+export type WalletNotification = InstanceType<
+  (typeof WalletNotification)[keyof Omit<
+    typeof WalletNotification,
+    "instanceOf"
+  >]
+>;
+
+// FfiConverter for enum WalletNotification
+const FfiConverterTypeWalletNotification = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = WalletNotification;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new WalletNotification.MovementCreated({
+            movement: FfiConverterTypeMovement.read(from),
+          });
+        case 2:
+          return new WalletNotification.MovementUpdated({
+            movement: FfiConverterTypeMovement.read(from),
+          });
+        case 3:
+          return new WalletNotification.ChannelLagging();
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case WalletNotification_Tags.MovementCreated: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterTypeMovement.write(inner.movement, into);
+          return;
+        }
+        case WalletNotification_Tags.MovementUpdated: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterTypeMovement.write(inner.movement, into);
+          return;
+        }
+        case WalletNotification_Tags.ChannelLagging: {
+          ordinalConverter.write(3, into);
+          return;
+        }
+        default:
+          // Throwing from here means that WalletNotification_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case WalletNotification_Tags.MovementCreated: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterTypeMovement.allocationSize(inner.movement);
+          return size;
+        }
+        case WalletNotification_Tags.MovementUpdated: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterTypeMovement.allocationSize(inner.movement);
+          return size;
+        }
+        case WalletNotification_Tags.ChannelLagging: {
+          return ordinalConverter.allocationSize(3);
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Pull-based handle for consuming wallet notifications.
+ *
+ * Obtain via `Wallet.notifications()`. Call `next_notification()` in a loop
+ * to receive events. Call `cancel_next_notification_wait()` to unblock a
+ * pending wait without destroying the underlying stream.
+ *
+ * Each call to `Wallet.notifications()` creates an independent stream backed
+ * by a new broadcast receiver. Only one consumer loop per holder is assumed.
+ */
+export interface NotificationHolderInterface {
+  /**
+   * Cancel the currently pending `next_notification()` wait.
+   *
+   * Causes a blocked `next_notification()` to return null.
+   * Has no effect when no wait is active.
+   * Does NOT destroy the underlying stream; subsequent calls to
+   * `next_notification()` will still work.
+   */
+  cancelNextNotificationWait(): void;
+  /**
+   * Wait for the next notification.
+   *
+   * Returns null if the wait was cancelled via `cancel_next_notification_wait()`
+   * or if the wallet's notification source was shut down permanently.
+   *
+   * After a cancellation this method can be called again normally — the
+   * underlying stream is preserved and a fresh cancel channel is set up on
+   * every entry.
+   *
+   * Throws `BarkError.Internal` if called concurrently on the same holder.
+   */
+  nextNotification(asyncOpts_?: {
+    signal: AbortSignal;
+  }): /*throws*/ Promise<WalletNotification | undefined>;
+}
+
+/**
+ * Pull-based handle for consuming wallet notifications.
+ *
+ * Obtain via `Wallet.notifications()`. Call `next_notification()` in a loop
+ * to receive events. Call `cancel_next_notification_wait()` to unblock a
+ * pending wait without destroying the underlying stream.
+ *
+ * Each call to `Wallet.notifications()` creates an independent stream backed
+ * by a new broadcast receiver. Only one consumer loop per holder is assumed.
+ */
+export class NotificationHolder
+  extends UniffiAbstractObject
+  implements NotificationHolderInterface
+{
+  readonly [uniffiTypeNameSymbol] = "NotificationHolder";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  // No primary constructor declared for this class.
+  private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] =
+      uniffiTypeNotificationHolderObjectFactory.bless(pointer);
+  }
+
+  /**
+   * Cancel the currently pending `next_notification()` wait.
+   *
+   * Causes a blocked `next_notification()` to return null.
+   * Has no effect when no wait is active.
+   * Does NOT destroy the underlying stream; subsequent calls to
+   * `next_notification()` will still work.
+   */
+  cancelNextNotificationWait(): void {
+    uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_bark_ffi_fn_method_notificationholder_cancel_next_notification_wait(
+          uniffiTypeNotificationHolderObjectFactory.clonePointer(this),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+  }
+
+  /**
+   * Wait for the next notification.
+   *
+   * Returns null if the wait was cancelled via `cancel_next_notification_wait()`
+   * or if the wallet's notification source was shut down permanently.
+   *
+   * After a cancellation this method can be called again normally — the
+   * underlying stream is preserved and a fresh cancel channel is set up on
+   * every entry.
+   *
+   * Throws `BarkError.Internal` if called concurrently on the same holder.
+   */
+  async nextNotification(asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<WalletNotification | undefined> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_bark_ffi_fn_method_notificationholder_next_notification(
+            uniffiTypeNotificationHolderObjectFactory.clonePointer(this)
+          );
+        },
+        /*pollFunc:*/ nativeModule()
+          .ubrn_ffi_bark_ffi_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_bark_ffi_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_bark_ffi_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule()
+          .ubrn_ffi_bark_ffi_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterOptionalTypeWalletNotification.lift.bind(
+          FfiConverterOptionalTypeWalletNotification
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeBarkError.lift.bind(
+          FfiConverterTypeBarkError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeNotificationHolderObjectFactory.pointer(this);
+      uniffiTypeNotificationHolderObjectFactory.freePointer(pointer);
+      uniffiTypeNotificationHolderObjectFactory.unbless(ptr);
+      delete (this as any)[destructorGuardSymbol];
+    }
+  }
+
+  static instanceOf(obj: any): obj is NotificationHolder {
+    return uniffiTypeNotificationHolderObjectFactory.isConcreteType(obj);
+  }
+}
+
+const uniffiTypeNotificationHolderObjectFactory: UniffiObjectFactory<NotificationHolderInterface> =
+  (() => {
+    return {
+      create(pointer: UniffiHandle): NotificationHolderInterface {
+        const instance = Object.create(NotificationHolder.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "NotificationHolder";
+        return instance;
+      },
+
+      bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+          /*caller:*/ (status) =>
+            nativeModule().ubrn_uniffi_internal_fn_method_notificationholder_ffi__bless_pointer(
+              p,
+              status
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      unbless(ptr: UniffiGcObject) {
+        ptr.markDestroyed();
+      },
+
+      pointer(obj: NotificationHolderInterface): UniffiHandle {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+          throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+      },
+
+      clonePointer(obj: NotificationHolderInterface): UniffiHandle {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_bark_ffi_fn_clone_notificationholder(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_bark_ffi_fn_free_notificationholder(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      isConcreteType(obj: any): obj is NotificationHolderInterface {
+        return (
+          obj[destructorGuardSymbol] &&
+          obj[uniffiTypeNameSymbol] === "NotificationHolder"
+        );
+      },
+    };
+  })();
+// FfiConverter for NotificationHolderInterface
+const FfiConverterTypeNotificationHolder = new FfiConverterObject(
+  uniffiTypeNotificationHolderObjectFactory
+);
+
 /**
  * Onchain Bitcoin wallet for boarding and exits
  *
@@ -3770,6 +4188,18 @@ export interface WalletInterface {
    * Get all wallet movements (transaction history)
    */
   history(): /*throws*/ Array<Movement>;
+  /**
+   * Get wallet movements filtered by payment method
+   *
+   * # Arguments
+   *
+   * * `payment_method_type` - Type (e.g. "ark", "bitcoin", "invoice", "offer", "lightning_address", "custom")
+   * * `payment_method_value` - Value (e.g. an address or invoice string)
+   */
+  historyByPaymentMethod(
+    paymentMethodType: string,
+    paymentMethodValue: string
+  ): /*throws*/ Array<Movement>;
   /**
    * Import a serialized VTXO into the wallet
    *
@@ -3863,6 +4293,14 @@ export interface WalletInterface {
    * Returns an error if the server hasn't provided round timing info
    */
   nextRoundStartTime(): /*throws*/ /*u64*/ bigint;
+  /**
+   * Get a pull-based notification holder for this wallet.
+   *
+   * Call `next_notification()` in a loop to receive events.
+   * Call `cancel_next_notification_wait()` to unblock a pending wait without
+   * destroying the stream.
+   */
+  notifications(): NotificationHolderInterface;
   offboardAll(bitcoinAddress: string): /*throws*/ OffboardResult;
   /**
    * Offboard specific VTXOs to a Bitcoin address
@@ -3893,9 +4331,13 @@ export interface WalletInterface {
     amountSats: /*u64*/ bigint | undefined
   ): /*throws*/ LightningSend;
   /**
-   * Peek at an address at a specific index
+   * DEPRECATED: use `peek_address` instead
    */
   peakAddress(index: /*u32*/ number): /*throws*/ string;
+  /**
+   * Peek at an address at a specific index
+   */
+  peekAddress(index: /*u32*/ number): /*throws*/ string;
   /**
    * Get all VTXOs that are part of pending boards
    */
@@ -4017,7 +4459,9 @@ export interface WalletInterface {
    * Sync pending board transactions
    */
   syncPendingBoards(): /*throws*/ void;
-  tryClaimAllLightningReceives(wait: boolean): /*throws*/ void;
+  tryClaimAllLightningReceives(
+    wait: boolean
+  ): /*throws*/ Array<LightningReceive>;
   /**
    * Try to claim a specific lightning receive by payment hash
    *
@@ -4871,6 +5315,36 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
     );
   }
 
+  /**
+   * Get wallet movements filtered by payment method
+   *
+   * # Arguments
+   *
+   * * `payment_method_type` - Type (e.g. "ark", "bitcoin", "invoice", "offer", "lightning_address", "custom")
+   * * `payment_method_value` - Value (e.g. an address or invoice string)
+   */
+  historyByPaymentMethod(
+    paymentMethodType: string,
+    paymentMethodValue: string
+  ): Array<Movement> /*throws*/ {
+    return FfiConverterArrayTypeMovement.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeBarkError.lift.bind(
+          FfiConverterTypeBarkError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_history_by_payment_method(
+            uniffiTypeWalletObjectFactory.clonePointer(this),
+            FfiConverterString.lower(paymentMethodType),
+            FfiConverterString.lower(paymentMethodValue),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
   /**
    * Import a serialized VTXO into the wallet
    *
@@ -5198,6 +5672,27 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
     );
   }
 
+  /**
+   * Get a pull-based notification holder for this wallet.
+   *
+   * Call `next_notification()` in a loop to receive events.
+   * Call `cancel_next_notification_wait()` to unblock a pending wait without
+   * destroying the stream.
+   */
+  notifications(): NotificationHolderInterface {
+    return FfiConverterTypeNotificationHolder.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_notifications(
+            uniffiTypeWalletObjectFactory.clonePointer(this),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
   offboardAll(bitcoinAddress: string): OffboardResult /*throws*/ {
     return FfiConverterTypeOffboardResult.lift(
       uniffiCaller.rustCallWithError(
@@ -5318,7 +5813,7 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
   }
 
   /**
-   * Peek at an address at a specific index
+   * DEPRECATED: use `peek_address` instead
    */
   peakAddress(index: /*u32*/ number): string /*throws*/ {
     return FfiConverterString.lift(
@@ -5338,6 +5833,27 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
     );
   }
 
+  /**
+   * Peek at an address at a specific index
+   */
+  peekAddress(index: /*u32*/ number): string /*throws*/ {
+    return FfiConverterString.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeBarkError.lift.bind(
+          FfiConverterTypeBarkError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_peek_address(
+            uniffiTypeWalletObjectFactory.clonePointer(this),
+            FfiConverterUInt32.lower(index),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
   /**
    * Get all VTXOs that are part of pending boards
    */
@@ -5824,19 +6340,23 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
     );
   }
 
-  tryClaimAllLightningReceives(wait: boolean): void /*throws*/ {
-    uniffiCaller.rustCallWithError(
-      /*liftError:*/ FfiConverterTypeBarkError.lift.bind(
-        FfiConverterTypeBarkError
-      ),
-      /*caller:*/ (callStatus) => {
-        nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_try_claim_all_lightning_receives(
-          uniffiTypeWalletObjectFactory.clonePointer(this),
-          FfiConverterBool.lower(wait),
-          callStatus
-        );
-      },
-      /*liftString:*/ FfiConverterString.lift
+  tryClaimAllLightningReceives(
+    wait: boolean
+  ): Array<LightningReceive> /*throws*/ {
+    return FfiConverterArrayTypeLightningReceive.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeBarkError.lift.bind(
+          FfiConverterTypeBarkError
+        ),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_try_claim_all_lightning_receives(
+            uniffiTypeWalletObjectFactory.clonePointer(this),
+            FfiConverterBool.lower(wait),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
     );
   }
 
@@ -6079,6 +6599,11 @@ const FfiConverterArrayTypeVtxo = new FfiConverterArray(FfiConverterTypeVtxo);
 // FfiConverter for Array<string>
 const FfiConverterArrayString = new FfiConverterArray(FfiConverterString);
 
+// FfiConverter for WalletNotification | undefined
+const FfiConverterOptionalTypeWalletNotification = new FfiConverterOptional(
+  FfiConverterTypeWalletNotification
+);
+
 // FfiConverter for Array<string> | undefined
 const FfiConverterOptionalArrayString = new FfiConverterOptional(
   FfiConverterArrayString
@@ -6138,6 +6663,22 @@ function uniffiEnsureInitialized() {
       "uniffi_bark_ffi_checksum_func_validate_mnemonic"
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_bark_ffi_checksum_method_notificationholder_cancel_next_notification_wait() !==
+    48074
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_bark_ffi_checksum_method_notificationholder_cancel_next_notification_wait"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_bark_ffi_checksum_method_notificationholder_next_notification() !==
+    10262
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_bark_ffi_checksum_method_notificationholder_next_notification"
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_balance() !==
     22016
@@ -6410,6 +6951,14 @@ function uniffiEnsureInitialized() {
       "uniffi_bark_ffi_checksum_method_wallet_history"
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_history_by_payment_method() !==
+    52617
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_bark_ffi_checksum_method_wallet_history_by_payment_method"
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_import_vtxo() !==
     31318
@@ -6530,6 +7079,14 @@ function uniffiEnsureInitialized() {
       "uniffi_bark_ffi_checksum_method_wallet_next_round_start_time"
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_notifications() !==
+    32641
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_bark_ffi_checksum_method_wallet_notifications"
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_offboard_all() !==
     61123
@@ -6578,6 +7135,14 @@ function uniffiEnsureInitialized() {
       "uniffi_bark_ffi_checksum_method_wallet_peak_address"
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_peek_address() !==
+    35297
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_bark_ffi_checksum_method_wallet_peek_address"
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_board_vtxos() !==
     58145
@@ -6763,7 +7328,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_try_claim_all_lightning_receives() !==
-    53132
+    8587
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_try_claim_all_lightning_receives"
@@ -6936,6 +7501,7 @@ export default Object.freeze({
     FfiConverterTypeLightningSend,
     FfiConverterTypeMovement,
     FfiConverterTypeNetwork,
+    FfiConverterTypeNotificationHolder,
     FfiConverterTypeOffboardResult,
     FfiConverterTypeOnchainBalance,
     FfiConverterTypeOnchainWallet,
@@ -6944,6 +7510,7 @@ export default Object.freeze({
     FfiConverterTypeRoundState,
     FfiConverterTypeVtxo,
     FfiConverterTypeWallet,
+    FfiConverterTypeWalletNotification,
     FfiConverterTypeWalletProperties,
   },
 });