X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=ts%2Fbindings.mts;fp=ts%2Fbindings.mts;h=00440c9d8a8948ea7a902796058530360704e229;hb=1a1849cb9b6e08f4ca8ba2ec4adea1f063bf248d;hp=2c9c3640a96d29d6bdac52849d27232dc5df077d;hpb=0b07fe133fc9956d0ce1b96ebdb927252858ddc4;p=ldk-java

diff --git a/ts/bindings.mts b/ts/bindings.mts
index 2c9c3640..00440c9d 100644
--- a/ts/bindings.mts
+++ b/ts/bindings.mts
@@ -421,11 +421,11 @@ export enum ConfirmationTarget {
 }
 
 /**
- * Errors that may occur when constructing a new `RawInvoice` or `Invoice`
+ * Errors that may occur when constructing a new [`RawInvoice`] or [`Invoice`]
  */
 export enum CreationError {
 	/**
-	 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
+	 * The supplied description string was longer than 639 __bytes__ (see [`Description::new`])
 	 */
 	LDKCreationError_DescriptionTooLong,
 	/**
@@ -616,6 +616,48 @@ export enum Network {
 	
 }
 
+/**
+ * The reason the payment failed. Used in [`Event::PaymentFailed`].
+ */
+export enum PaymentFailureReason {
+	/**
+	 * The intended recipient rejected our payment.
+	 */
+	LDKPaymentFailureReason_RecipientRejected,
+	/**
+	 * The user chose to abandon this payment by calling [`ChannelManager::abandon_payment`].
+	
+	[`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
+	 */
+	LDKPaymentFailureReason_UserAbandoned,
+	/**
+	 * We exhausted all of our retry attempts while trying to send the payment, or we
+	exhausted the [`Retry::Timeout`] if the user set one. If at any point a retry
+	attempt failed while being forwarded along the path, an [`Event::PaymentPathFailed`] will
+	have come before this.
+	
+	[`Retry::Timeout`]: crate::ln::channelmanager::Retry::Timeout
+	 */
+	LDKPaymentFailureReason_RetriesExhausted,
+	/**
+	 * The payment expired while retrying, based on the provided
+	[`PaymentParameters::expiry_time`].
+	
+	[`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
+	 */
+	LDKPaymentFailureReason_PaymentExpired,
+	/**
+	 * We failed to find a route while retrying the payment.
+	 */
+	LDKPaymentFailureReason_RouteNotFound,
+	/**
+	 * This error should generally never happen. This likely means that there is a problem with
+	your router.
+	 */
+	LDKPaymentFailureReason_UnexpectedError,
+	
+}
+
 /**
  * Specifies the recipient of an invoice.
  * 
@@ -638,12 +680,12 @@ export enum Recipient {
 }
 
 /**
- * Indicates an immediate error on [`ChannelManager::send_payment_with_retry`]. Further errors
- * may be surfaced later via [`Event::PaymentPathFailed`] and [`Event::PaymentFailed`].
+ * Indicates an immediate error on [`ChannelManager::send_payment`]. Further errors may be
+ * surfaced later via [`Event::PaymentPathFailed`] and [`Event::PaymentFailed`].
  * 
- * [`ChannelManager::send_payment_with_retry`]: crate::ln::channelmanager::ChannelManager::send_payment_with_retry
- * [`Event::PaymentPathFailed`]: crate::util::events::Event::PaymentPathFailed
- * [`Event::PaymentFailed`]: crate::util::events::Event::PaymentFailed
+ * [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
+ * [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
+ * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
  */
 export enum RetryableSendFailure {
 	/**
@@ -662,8 +704,8 @@ export enum RetryableSendFailure {
 	yet completed (i.e. generated an [`Event::PaymentSent`] or [`Event::PaymentFailed`]).
 	
 	[`PaymentId`]: crate::ln::channelmanager::PaymentId
-	[`Event::PaymentSent`]: crate::util::events::Event::PaymentSent
-	[`Event::PaymentFailed`]: crate::util::events::Event::PaymentFailed
+	[`Event::PaymentSent`]: crate::events::Event::PaymentSent
+	[`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
 	 */
 	LDKRetryableSendFailure_DuplicatePayment,
 	
@@ -721,7 +763,7 @@ export enum Secp256k1Error {
 }
 
 /**
- * Errors that may occur when converting a `RawInvoice` to an `Invoice`. They relate to the
+ * Errors that may occur when converting a [`RawInvoice`] to an [`Invoice`]. They relate to the
  * requirements sections in BOLT #11
  */
 export enum SemanticError {
@@ -871,6 +913,46 @@ export function TxOut_get_value(thing: bigint): bigint {
 	return nativeResponseValue;
 }
 /* @internal */
+export class LDKCOption_DurationZ {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_DurationZ_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_DurationZ_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_DurationZ_Some_get_some(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_DurationZ_Some_get_some(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKCOption_u64Z {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_u64Z_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_u64Z_Some_get_some(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
 export class LDKAPIError {
 	protected constructor() {}
 }
@@ -949,62 +1031,100 @@ export function CResult_NoneAPIErrorZ_get_err(owner: bigint): bigint {
 	return nativeResponseValue;
 }
 /* @internal */
-export class LDKCOption_HTLCClaimZ {
+export class LDKCOption_CVec_u8ZZ {
 	protected constructor() {}
 }
 /* @internal */
-export function LDKCOption_HTLCClaimZ_ty_from_ptr(ptr: bigint): number {
+export function LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKCOption_HTLCClaimZ_Some_get_some(ptr: bigint): HTLCClaim {
+export function LDKCOption_CVec_u8ZZ_Some_get_some(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_Some_get_some(ptr);
+	const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_Some_get_some(ptr);
 	return nativeResponseValue;
 }
-	// void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
+export class LDKDecodeError {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKDecodeError_ty_from_ptr(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_LDKDecodeError_ty_from_ptr(ptr);
+	return nativeResponseValue;
 }
-	// void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_NoneNoneZ_get_err(owner: bigint): void {
+export function LDKDecodeError_Io_get_io(ptr: bigint): IOError {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_LDKDecodeError_Io_get_io(ptr);
+	return nativeResponseValue;
 }
+	// struct LDKRecipientOnionFields CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export class LDKDecodeError {
+export function CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// struct LDKDecodeError CResult_RecipientOnionFieldsDecodeErrorZ_get_err(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKCOption_HTLCClaimZ {
 	protected constructor() {}
 }
 /* @internal */
-export function LDKDecodeError_ty_from_ptr(ptr: bigint): number {
+export function LDKCOption_HTLCClaimZ_ty_from_ptr(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKDecodeError_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_ty_from_ptr(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKDecodeError_Io_get_io(ptr: bigint): IOError {
+export function LDKCOption_HTLCClaimZ_Some_get_some(ptr: bigint): HTLCClaim {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKDecodeError_Io_get_io(ptr);
+	const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_Some_get_some(ptr);
 	return nativeResponseValue;
+}
+	// void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
+	// debug statements here
+}
+	// void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_NoneNoneZ_get_err(owner: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
+	// debug statements here
 }
 	// struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
@@ -1278,58 +1398,22 @@ export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: bigi
 	const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
 	return nativeResponseValue;
 }
-	// struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_BlindedPathNoneZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_BlindedPathNoneZ_get_err(owner: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_err(owner);
-	// debug statements here
-}
-	// struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_BlindedPathDecodeErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_BlindedPathDecodeErrorZ_get_err(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
+	// struct LDKBlindedPayInfo CResult_BlindedPayInfoDecodeErrorZ_get_ok(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_BlindedHopDecodeErrorZ_get_ok(owner: bigint): bigint {
+export function CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_ok(owner);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
-	// struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
+	// struct LDKDecodeError CResult_BlindedPayInfoDecodeErrorZ_get_err(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_BlindedHopDecodeErrorZ_get_err(owner: bigint): bigint {
+export function CResult_BlindedPayInfoDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_err(owner);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
 	// struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
@@ -1349,26 +1433,6 @@ export function CResult_RouteLightningErrorZ_get_err(owner: bigint): bigint {
 	}
 	const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
 	return nativeResponseValue;
-}
-/* @internal */
-export class LDKCOption_u64Z {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKCOption_u64Z_ty_from_ptr(ptr: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKCOption_u64Z_Some_get_some(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
-	return nativeResponseValue;
 }
 	// struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
@@ -1405,6 +1469,24 @@ export function CResult_RouteHopDecodeErrorZ_get_err(owner: bigint): bigint {
 	}
 	const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
+}
+	// struct LDKBlindedTail CResult_BlindedTailDecodeErrorZ_get_ok(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_get_ok(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// struct LDKDecodeError CResult_BlindedTailDecodeErrorZ_get_err(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_get_err(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_err(owner);
+	return nativeResponseValue;
 }
 	// struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
@@ -1459,6 +1541,24 @@ export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: bigint): bi
 	}
 	const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
+}
+	// struct LDKBlindedPayInfo C2Tuple_BlindedPayInfoBlindedPathZ_get_a(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
+/* @internal */
+export function C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner);
+	return nativeResponseValue;
+}
+	// struct LDKBlindedPath C2Tuple_BlindedPayInfoBlindedPathZ_get_b(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
+/* @internal */
+export function C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner);
+	return nativeResponseValue;
 }
 	// struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
@@ -1496,464 +1596,872 @@ export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: bigint): bigint
 	const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
+	// uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
 /* @internal */
-export class LDKPaymentPurpose {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
+export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
 	return nativeResponseValue;
 }
+	// struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: bigint): number {
+export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
+	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
 	return nativeResponseValue;
 }
+	// struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_a(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: bigint): number {
+export function C2Tuple_TxidBlockHashZ_get_a(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
+	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_get_a(owner);
 	return nativeResponseValue;
 }
+	// struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_b(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
+export function C2Tuple_TxidBlockHashZ_get_b(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
+	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_get_b(owner);
 	return nativeResponseValue;
 }
-	// struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
+export class LDKMonitorEvent {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
+	const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
 	return nativeResponseValue;
 }
-	// struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
+export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
+	const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export class LDKNetworkUpdate {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
+export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
+export function LDKMonitorEvent_Completed_get_funding_txo(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
+	const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_funding_txo(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
+export function LDKMonitorEvent_Completed_get_monitor_update_id(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
+	const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_monitor_update_id(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
+export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
+	const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
 	return nativeResponseValue;
 }
+	// struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
+export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
+	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
 	return nativeResponseValue;
 }
+	// struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
+export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
+	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
 	return nativeResponseValue;
 }
+	// struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
 /* @internal */
-export class LDKCOption_NetworkUpdateZ {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
+export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
 	return nativeResponseValue;
 }
+	// struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
+export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
+	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
+	// struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export class LDKPathFailure {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKPathFailure_ty_from_ptr(ptr: bigint): number {
+export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKPathFailure_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
+	// uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
 /* @internal */
-export function LDKPathFailure_InitialSend_get_err(ptr: bigint): bigint {
+export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKPathFailure_InitialSend_get_err(ptr);
+	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
 	return nativeResponseValue;
 }
+	// uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
 /* @internal */
-export function LDKPathFailure_OnPath_get_network_update(ptr: bigint): bigint {
+export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKPathFailure_OnPath_get_network_update(ptr);
+	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
 	return nativeResponseValue;
 }
 /* @internal */
-export class LDKCOption_PathFailureZ {
+export class LDKCOption_C2Tuple_u64u64ZZ {
 	protected constructor() {}
 }
 /* @internal */
-export function LDKCOption_PathFailureZ_ty_from_ptr(ptr: bigint): number {
+export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKCOption_PathFailureZ_Some_get_some(ptr: bigint): bigint {
+export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_Some_get_some(ptr);
+	const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_PathFailureZ CResult_COption_PathFailureZDecodeErrorZ_get_ok(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
+	// struct LDKEightU16s C2Tuple_Z_get_a(LDKC2Tuple_Z *NONNULL_PTR owner);
 /* @internal */
-export function CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner: bigint): bigint {
+export function C2Tuple_Z_get_a(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner);
+	const nativeResponseValue = wasm.TS_C2Tuple_Z_get_a(owner);
 	return nativeResponseValue;
 }
-	// struct LDKDecodeError CResult_COption_PathFailureZDecodeErrorZ_get_err(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
+	// struct LDKEightU16s C2Tuple_Z_get_b(LDKC2Tuple_Z *NONNULL_PTR owner);
 /* @internal */
-export function CResult_COption_PathFailureZDecodeErrorZ_get_err(owner: bigint): bigint {
+export function C2Tuple_Z_get_b(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_err(owner);
+	const nativeResponseValue = wasm.TS_C2Tuple_Z_get_b(owner);
 	return nativeResponseValue;
 }
+	// struct LDKEightU16s C2Tuple__u168_u168Z_get_a(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner);
 /* @internal */
-export class LDKClosureReason {
-	protected constructor() {}
+export function C2Tuple__u168_u168Z_get_a(owner: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_get_a(owner);
+	return nativeResponseValue;
 }
+	// struct LDKEightU16s C2Tuple__u168_u168Z_get_b(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner);
 /* @internal */
-export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
+export function C2Tuple__u168_u168Z_get_b(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_get_b(owner);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): number {
+export class LDKCOption_C2Tuple_EightU16sEightU16sZZ {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
+	const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
+export function LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
+	const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export class LDKCOption_ClosureReasonZ {
-	protected constructor() {}
+export interface LDKLogger {
+	log (record: bigint): void;
 }
+
 /* @internal */
-export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
+export function LDKLogger_new(impl: LDKLogger): [bigint, number] {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
-	return nativeResponseValue;
+	var new_obj_idx = js_objs.length;
+	for (var i = 0; i < js_objs.length; i++) {
+		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+	}
+	js_objs[i] = new WeakRef(impl);
+	return [wasm.TS_LDKLogger_new(i), i];
 }
+	// struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
+export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
+	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
+	// struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
+export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
+	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
-	// struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
+	// struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
+export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
+	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
+	// struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export class LDKHTLCDestination {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
+export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
+	// struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
+export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
+	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
+	// struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): number {
+export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
+	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
+	// struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
+export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
+	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
+	// struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr: bigint): bigint {
+export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr);
+	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
+	// struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
+export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
+	// struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export class LDKCOption_HTLCDestinationZ {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
+export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
+	// struct LDKBlindedHopFeatures CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
+export function CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
+	// struct LDKDecodeError CResult_BlindedHopFeaturesDecodeErrorZ_get_err(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
+export function CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
-	// struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
+	// struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
+	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
+	// struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export class LDKCOption_u128Z {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKCOption_u128Z_ty_from_ptr(ptr: bigint): number {
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_u128Z_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKCOption_u128Z_Some_get_some(ptr: bigint): number {
+export class LDKPaymentPurpose {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_u128Z_Some_get_some(ptr);
+	const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export class LDKSpendableOutputDescriptor {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
+export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
+export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
+	const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
+export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
+	const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
 	return nativeResponseValue;
 }
+	// struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
+export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
+	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
+	// struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
+export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
+	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
 /* @internal */
-export class LDKEvent {
+export class LDKNetworkUpdate {
 	protected constructor() {}
 }
 /* @internal */
-export function LDKEvent_ty_from_ptr(ptr: bigint): number {
+export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): number {
+export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
+	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
+export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
+	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
+export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
+	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
+export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
+	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): number {
+export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKCOption_NetworkUpdateZ {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKPathFailure {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKPathFailure_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKPathFailure_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKPathFailure_InitialSend_get_err(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKPathFailure_InitialSend_get_err(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKPathFailure_OnPath_get_network_update(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKPathFailure_OnPath_get_network_update(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKCOption_PathFailureZ {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_PathFailureZ_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_PathFailureZ_Some_get_some(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_Some_get_some(ptr);
+	return nativeResponseValue;
+}
+	// struct LDKCOption_PathFailureZ CResult_COption_PathFailureZDecodeErrorZ_get_ok(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// struct LDKDecodeError CResult_COption_PathFailureZDecodeErrorZ_get_err(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_COption_PathFailureZDecodeErrorZ_get_err(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_err(owner);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKClosureReason {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKCOption_ClosureReasonZ {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
+	return nativeResponseValue;
+}
+	// struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKHTLCDestination {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKCOption_HTLCDestinationZ {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
+	return nativeResponseValue;
+}
+	// struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
+	return nativeResponseValue;
+}
+	// enum LDKPaymentFailureReason CResult_PaymentFailureReasonDecodeErrorZ_get_ok(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner: bigint): PaymentFailureReason {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// struct LDKDecodeError CResult_PaymentFailureReasonDecodeErrorZ_get_err(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKCOption_u128Z {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_u128Z_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_u128Z_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_u128Z_Some_get_some(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_u128Z_Some_get_some(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKCOption_PaymentFailureReasonZ {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr: bigint): PaymentFailureReason {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKSpendableOutputDescriptor {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export class LDKEvent {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKEvent_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
@@ -1977,6 +2485,14 @@ export function LDKEvent_PaymentClaimable_get_payment_hash(ptr: bigint): number
 	return nativeResponseValue;
 }
 /* @internal */
+export function LDKEvent_PaymentClaimable_get_onion_fields(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_onion_fields(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
 export function LDKEvent_PaymentClaimable_get_amount_msat(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
@@ -2009,6 +2525,14 @@ export function LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr: bigint):
 	return nativeResponseValue;
 }
 /* @internal */
+export function LDKEvent_PaymentClaimable_get_claim_deadline(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_claim_deadline(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
 export function LDKEvent_PaymentClaimed_get_receiver_node_id(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
@@ -2089,6 +2613,14 @@ export function LDKEvent_PaymentFailed_get_payment_hash(ptr: bigint): number {
 	return nativeResponseValue;
 }
 /* @internal */
+export function LDKEvent_PaymentFailed_get_reason(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_reason(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
@@ -2105,7 +2637,7 @@ export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: bigint): nu
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): number {
+export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
@@ -2145,7 +2677,7 @@ export function LDKEvent_PaymentPathFailed_get_failure(ptr: bigint): bigint {
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): number {
+export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
@@ -2161,14 +2693,6 @@ export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: bigint): bi
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKEvent_PaymentPathFailed_get_retry(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
@@ -2185,7 +2709,7 @@ export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: bigint): number {
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): number {
+export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
@@ -2209,7 +2733,7 @@ export function LDKEvent_ProbeFailed_get_payment_hash(ptr: bigint): number {
 	return nativeResponseValue;
 }
 /* @internal */
-export function LDKEvent_ProbeFailed_get_path(ptr: bigint): number {
+export function LDKEvent_ProbeFailed_get_path(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
@@ -2313,6 +2837,54 @@ export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: bigint)
 	return nativeResponseValue;
 }
 /* @internal */
+export function LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKEvent_ChannelPending_get_channel_id(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_channel_id(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKEvent_ChannelPending_get_user_channel_id(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_user_channel_id(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKEvent_ChannelPending_get_counterparty_node_id(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_counterparty_node_id(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKEvent_ChannelPending_get_funding_txo(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_funding_txo(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
 export function LDKEvent_ChannelReady_get_channel_id(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
@@ -2870,374 +3442,22 @@ export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: bigin
 	const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
 	return nativeResponseValue;
 }
-	// uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
-/* @internal */
-export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
-	return nativeResponseValue;
-}
-	// struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
-/* @internal */
-export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
-	return nativeResponseValue;
-}
-	// struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_a(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner);
-/* @internal */
-export function C2Tuple_TxidBlockHashZ_get_a(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_get_a(owner);
-	return nativeResponseValue;
-}
-	// struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_b(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner);
-/* @internal */
-export function C2Tuple_TxidBlockHashZ_get_b(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_get_b(owner);
-	return nativeResponseValue;
-}
-/* @internal */
-export class LDKMonitorEvent {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKMonitorEvent_Completed_get_funding_txo(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_funding_txo(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKMonitorEvent_Completed_get_monitor_update_id(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_monitor_update_id(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
-	return nativeResponseValue;
-}
-	// struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
-/* @internal */
-export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
-	return nativeResponseValue;
-}
-	// struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
-/* @internal */
-export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
-	return nativeResponseValue;
-}
-	// struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
-/* @internal */
-export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
-	return nativeResponseValue;
-}
-	// struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
-/* @internal */
-export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
-	return nativeResponseValue;
-}
-	// uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
-/* @internal */
-export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
-	return nativeResponseValue;
-}
-/* @internal */
-export class LDKCOption_C2Tuple_u64u64ZZ {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
-	return nativeResponseValue;
-}
-	// struct LDKEightU16s C2Tuple_Z_get_a(LDKC2Tuple_Z *NONNULL_PTR owner);
-/* @internal */
-export function C2Tuple_Z_get_a(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C2Tuple_Z_get_a(owner);
-	return nativeResponseValue;
-}
-	// struct LDKEightU16s C2Tuple_Z_get_b(LDKC2Tuple_Z *NONNULL_PTR owner);
-/* @internal */
-export function C2Tuple_Z_get_b(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C2Tuple_Z_get_b(owner);
-	return nativeResponseValue;
-}
-	// struct LDKEightU16s C2Tuple__u168_u168Z_get_a(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner);
-/* @internal */
-export function C2Tuple__u168_u168Z_get_a(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_get_a(owner);
-	return nativeResponseValue;
-}
-	// struct LDKEightU16s C2Tuple__u168_u168Z_get_b(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner);
-/* @internal */
-export function C2Tuple__u168_u168Z_get_b(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_get_b(owner);
-	return nativeResponseValue;
-}
-/* @internal */
-export class LDKCOption_C2Tuple_EightU16sEightU16sZZ {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr(ptr: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export interface LDKLogger {
-	log (record: bigint): void;
-}
-
-/* @internal */
-export function LDKLogger_new(impl: LDKLogger): [bigint, number] {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	var new_obj_idx = js_objs.length;
-	for (var i = 0; i < js_objs.length; i++) {
-		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
-	}
-	js_objs[i] = new WeakRef(impl);
-	return [wasm.TS_LDKLogger_new(i), i];
-}
-	// struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// struct LDKBlindedHopFeatures CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// struct LDKDecodeError CResult_BlindedHopFeaturesDecodeErrorZ_get_err(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
+	// struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
+export function CResult_PublicKeyErrorZ_get_ok(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
+	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
-	// struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
+	// enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
+export function CResult_PublicKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
+	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
 	// struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
@@ -5007,6 +5227,24 @@ export function CResult_COption_APIErrorZDecodeErrorZ_get_err(owner: bigint): bi
 	}
 	const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
+}
+	// struct LDKUntrustedString CResult_UntrustedStringDecodeErrorZ_get_ok(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_UntrustedStringDecodeErrorZ_get_ok(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// struct LDKDecodeError CResult_UntrustedStringDecodeErrorZ_get_err(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_UntrustedStringDecodeErrorZ_get_err(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_err(owner);
+	return nativeResponseValue;
 }
 	// struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
@@ -5191,24 +5429,6 @@ export function CResult_StringErrorZ_get_err(owner: bigint): Secp256k1Error {
 	}
 	const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
 	return nativeResponseValue;
-}
-	// struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_PublicKeyErrorZ_get_ok(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_PublicKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
-	return nativeResponseValue;
 }
 	// struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
@@ -5724,319 +5944,104 @@ export function CResult_NoneSendErrorZ_get_err(owner: bigint): bigint {
 	const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
+	// struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
 /* @internal */
-export class LDKGraphSyncError {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKGraphSyncError_ty_from_ptr(ptr: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKGraphSyncError_ty_from_ptr(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKGraphSyncError_DecodeError_get_decode_error(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKGraphSyncError_DecodeError_get_decode_error(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKGraphSyncError_LightningError_get_lightning_error(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKGraphSyncError_LightningError_get_lightning_error(ptr);
-	return nativeResponseValue;
-}
-	// uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_u32GraphSyncErrorZ_get_ok(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_u32GraphSyncErrorZ_get_err(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-/* @internal */
-export class LDKParseError {
-	protected constructor() {}
-}
-/* @internal */
-export function LDKParseError_ty_from_ptr(ptr: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
+export function CResult_BlindedPathNoneZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_ok(owner);
 	return nativeResponseValue;
 }
+	// void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
+export function CResult_BlindedPathNoneZ_get_err(owner: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_err(owner);
+	// debug statements here
 }
+	// struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
+export function CResult_BlindedPathDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
+	// struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
+export function CResult_BlindedPathDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
-	// enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
+	// struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_SiPrefixParseErrorZ_get_ok(owner: bigint): SiPrefix {
+export function CResult_BlindedHopDecodeErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
-	// struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
+	// struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_SiPrefixParseErrorZ_get_err(owner: bigint): bigint {
+export function CResult_BlindedHopDecodeErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
 /* @internal */
-export class LDKParseOrSemanticError {
+export class LDKGraphSyncError {
 	protected constructor() {}
 }
 /* @internal */
-export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
-	return nativeResponseValue;
-}
-/* @internal */
-export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): SemanticError {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
-	return nativeResponseValue;
-}
-	// struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
-/* @internal */
-export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
-	return nativeResponseValue;
-}
-	// struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
-/* @internal */
-export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: bigint): number {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
-	return nativeResponseValue;
-}
-	// struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
-/* @internal */
-export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
-	return nativeResponseValue;
-}
-	// struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_PayeePubKeyErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_PayeePubKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_NoneSemanticErrorZ_get_ok(owner: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
-	// debug statements here
-}
-	// enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_NoneSemanticErrorZ_get_err(owner: bigint): SemanticError {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
-	return nativeResponseValue;
-}
-	// struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_InvoiceSemanticErrorZ_get_ok(owner: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
-	return nativeResponseValue;
-}
-	// enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_InvoiceSemanticErrorZ_get_err(owner: bigint): SemanticError {
+export function LDKGraphSyncError_ty_from_ptr(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
+	const nativeResponseValue = wasm.TS_LDKGraphSyncError_ty_from_ptr(ptr);
 	return nativeResponseValue;
 }
-	// struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
+export function LDKGraphSyncError_DecodeError_get_decode_error(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
+	const nativeResponseValue = wasm.TS_LDKGraphSyncError_DecodeError_get_decode_error(ptr);
 	return nativeResponseValue;
 }
-	// enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
+export function LDKGraphSyncError_LightningError_get_lightning_error(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
+	const nativeResponseValue = wasm.TS_LDKGraphSyncError_LightningError_get_lightning_error(ptr);
 	return nativeResponseValue;
 }
-	// struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
+	// uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
+export function CResult_u32GraphSyncErrorZ_get_ok(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
+	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
-	// enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
+	// struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
+export function CResult_u32GraphSyncErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
+	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
 	// void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
@@ -6688,6 +6693,98 @@ export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: bigint)
 	return nativeResponseValue;
 }
 /* @internal */
+export interface LDKFilter {
+	register_tx (txid: number, script_pubkey: number): void;
+	register_output (output: bigint): void;
+}
+
+/* @internal */
+export function LDKFilter_new(impl: LDKFilter): [bigint, number] {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	var new_obj_idx = js_objs.length;
+	for (var i = 0; i < js_objs.length; i++) {
+		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+	}
+	js_objs[i] = new WeakRef(impl);
+	return [wasm.TS_LDKFilter_new(i), i];
+}
+	// void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
+/* @internal */
+export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
+	// debug statements here
+}
+	// void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
+/* @internal */
+export function Filter_register_output(this_arg: bigint, output: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
+	// debug statements here
+}
+/* @internal */
+export class LDKCOption_FilterZ {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
+	return nativeResponseValue;
+}
+	// struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
+	// debug statements here
+}
+	// struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
+/* @internal */
+export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
+/* @internal */
+export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner);
+	return nativeResponseValue;
+}
+/* @internal */
 export class LDKSignOrCreationError {
 	protected constructor() {}
 }
@@ -6726,208 +6823,281 @@ export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: bigint): bigi
 	return nativeResponseValue;
 }
 /* @internal */
-export interface LDKFilter {
-	register_tx (txid: number, script_pubkey: number): void;
-	register_output (output: bigint): void;
+export class LDKParseError {
+	protected constructor() {}
 }
-
 /* @internal */
-export function LDKFilter_new(impl: LDKFilter): [bigint, number] {
+export function LDKParseError_ty_from_ptr(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	var new_obj_idx = js_objs.length;
-	for (var i = 0; i < js_objs.length; i++) {
-		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+	const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
 	}
-	js_objs[i] = new WeakRef(impl);
-	return [wasm.TS_LDKFilter_new(i), i];
+	const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
+	return nativeResponseValue;
 }
-	// void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
 /* @internal */
-export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
+export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
+	return nativeResponseValue;
 }
-	// void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
 /* @internal */
-export function Filter_register_output(this_arg: bigint, output: bigint): void {
+export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
+	return nativeResponseValue;
 }
 /* @internal */
-export class LDKCOption_FilterZ {
-	protected constructor() {}
+export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
+	return nativeResponseValue;
 }
 /* @internal */
-export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
+export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
+	const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
 	return nativeResponseValue;
 }
+	// enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
+export function CResult_SiPrefixParseErrorZ_get_ok(owner: bigint): SiPrefix {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
+	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
-	// struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
+	// struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
+export function CResult_SiPrefixParseErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
+	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
-	// void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
 /* @internal */
-export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
+export class LDKParseOrSemanticError {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
+	return nativeResponseValue;
 }
-	// struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
 /* @internal */
-export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner: bigint): bigint {
+export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner);
+	const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
 /* @internal */
-export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner: bigint): number {
+export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): SemanticError {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner);
+	const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
 	return nativeResponseValue;
 }
+	// struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
 /* @internal */
-export interface LDKMessageSendEventsProvider {
-	get_and_clear_pending_msg_events (): number;
+export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
+	return nativeResponseValue;
 }
-
+	// struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): [bigint, number] {
+export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	var new_obj_idx = js_objs.length;
-	for (var i = 0; i < js_objs.length; i++) {
-		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
+	return nativeResponseValue;
+}
+	// struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
 	}
-	js_objs[i] = new WeakRef(impl);
-	return [wasm.TS_LDKMessageSendEventsProvider_new(i), i];
+	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
+	return nativeResponseValue;
 }
-	// LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
+	// struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
+export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
+	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
 	return nativeResponseValue;
 }
+	// struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
 /* @internal */
-export interface LDKOnionMessageProvider {
-	next_onion_message_for_peer (peer_node_id: number): bigint;
+export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
+	return nativeResponseValue;
 }
-
+	// struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKOnionMessageProvider_new(impl: LDKOnionMessageProvider): [bigint, number] {
+export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	var new_obj_idx = js_objs.length;
-	for (var i = 0; i < js_objs.length; i++) {
-		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
+	return nativeResponseValue;
+}
+	// struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
+/* @internal */
+export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
 	}
-	js_objs[i] = new WeakRef(impl);
-	return [wasm.TS_LDKOnionMessageProvider_new(i), i];
+	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
+	return nativeResponseValue;
 }
-	// LDKOnionMessage OnionMessageProvider_next_onion_message_for_peer LDKOnionMessageProvider *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
+	// struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function OnionMessageProvider_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
+export function CResult_PayeePubKeyErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_OnionMessageProvider_next_onion_message_for_peer(this_arg, peer_node_id);
+	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
 	return nativeResponseValue;
 }
+	// enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
 /* @internal */
-export interface LDKEventHandler {
-	handle_event (event: bigint): void;
+export function CResult_PayeePubKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
+	return nativeResponseValue;
 }
-
+	// struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKEventHandler_new(impl: LDKEventHandler): [bigint, number] {
+export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	var new_obj_idx = js_objs.length;
-	for (var i = 0; i < js_objs.length; i++) {
-		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
 	}
-	js_objs[i] = new WeakRef(impl);
-	return [wasm.TS_LDKEventHandler_new(i), i];
+	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
+	return nativeResponseValue;
 }
-	// void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, struct LDKEvent event
+	// void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
+export function CResult_NoneSemanticErrorZ_get_ok(owner: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
+	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
 	// debug statements here
 }
+	// enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
 /* @internal */
-export interface LDKEventsProvider {
-	process_pending_events (handler: bigint): void;
+export function CResult_NoneSemanticErrorZ_get_err(owner: bigint): SemanticError {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
+	return nativeResponseValue;
 }
-
+	// struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function LDKEventsProvider_new(impl: LDKEventsProvider): [bigint, number] {
+export function CResult_InvoiceSemanticErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	var new_obj_idx = js_objs.length;
-	for (var i = 0; i < js_objs.length; i++) {
-		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_InvoiceSemanticErrorZ_get_err(owner: bigint): SemanticError {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
 	}
-	js_objs[i] = new WeakRef(impl);
-	return [wasm.TS_LDKEventsProvider_new(i), i];
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
+	return nativeResponseValue;
 }
-	// void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
+	// struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
 /* @internal */
-export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
+export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
+	return nativeResponseValue;
+}
+	// struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
+	return nativeResponseValue;
+}
+	// enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
+	return nativeResponseValue;
 }
 /* @internal */
 export interface LDKScore {
 	channel_penalty_msat (short_channel_id: bigint, source: bigint, target: bigint, usage: bigint): bigint;
-	payment_path_failed (path: number, short_channel_id: bigint): void;
-	payment_path_successful (path: number): void;
-	probe_failed (path: number, short_channel_id: bigint): void;
-	probe_successful (path: number): void;
+	payment_path_failed (path: bigint, short_channel_id: bigint): void;
+	payment_path_successful (path: bigint): void;
+	probe_failed (path: bigint, short_channel_id: bigint): void;
+	probe_successful (path: bigint): void;
 	write (): number;
 }
 
@@ -6952,36 +7122,36 @@ export function Score_channel_penalty_msat(this_arg: bigint, short_channel_id: b
 	const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
 	return nativeResponseValue;
 }
-	// void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
+	// void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id
 /* @internal */
-export function Score_payment_path_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
+export function Score_payment_path_failed(this_arg: bigint, path: bigint, short_channel_id: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
 	const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
 	// debug statements here
 }
-	// void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
+	// void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path
 /* @internal */
-export function Score_payment_path_successful(this_arg: bigint, path: number): void {
+export function Score_payment_path_successful(this_arg: bigint, path: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
 	const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
 	// debug statements here
 }
-	// void Score_probe_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
+	// void Score_probe_failed LDKScore *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id
 /* @internal */
-export function Score_probe_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
+export function Score_probe_failed(this_arg: bigint, path: bigint, short_channel_id: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
 	const nativeResponseValue = wasm.TS_Score_probe_failed(this_arg, path, short_channel_id);
 	// debug statements here
 }
-	// void Score_probe_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
+	// void Score_probe_successful LDKScore *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path
 /* @internal */
-export function Score_probe_successful(this_arg: bigint, path: number): void {
+export function Score_probe_successful(this_arg: bigint, path: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
@@ -7260,6 +7430,58 @@ export function Persist_update_persisted_channel(this_arg: bigint, channel_id: b
 	return nativeResponseValue;
 }
 /* @internal */
+export interface LDKEventHandler {
+	handle_event (event: bigint): void;
+}
+
+/* @internal */
+export function LDKEventHandler_new(impl: LDKEventHandler): [bigint, number] {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	var new_obj_idx = js_objs.length;
+	for (var i = 0; i < js_objs.length; i++) {
+		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+	}
+	js_objs[i] = new WeakRef(impl);
+	return [wasm.TS_LDKEventHandler_new(i), i];
+}
+	// void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, struct LDKEvent event
+/* @internal */
+export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
+	// debug statements here
+}
+/* @internal */
+export interface LDKEventsProvider {
+	process_pending_events (handler: bigint): void;
+}
+
+/* @internal */
+export function LDKEventsProvider_new(impl: LDKEventsProvider): [bigint, number] {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	var new_obj_idx = js_objs.length;
+	for (var i = 0; i < js_objs.length; i++) {
+		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+	}
+	js_objs[i] = new WeakRef(impl);
+	return [wasm.TS_LDKEventsProvider_new(i), i];
+}
+	// void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
+/* @internal */
+export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
+	// debug statements here
+}
+/* @internal */
 export class LDKRetry {
 	protected constructor() {}
 }
@@ -7280,6 +7502,32 @@ export function LDKRetry_Attempts_get_attempts(ptr: bigint): number {
 	return nativeResponseValue;
 }
 /* @internal */
+export interface LDKMessageSendEventsProvider {
+	get_and_clear_pending_msg_events (): number;
+}
+
+/* @internal */
+export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): [bigint, number] {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	var new_obj_idx = js_objs.length;
+	for (var i = 0; i < js_objs.length; i++) {
+		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+	}
+	js_objs[i] = new WeakRef(impl);
+	return [wasm.TS_LDKMessageSendEventsProvider_new(i), i];
+}
+	// LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
+/* @internal */
+export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
+	return nativeResponseValue;
+}
+/* @internal */
 export interface LDKChannelMessageHandler {
 	handle_open_channel (their_node_id: number, msg: bigint): void;
 	handle_accept_channel (their_node_id: number, msg: bigint): void;
@@ -7662,6 +7910,32 @@ export function RoutingMessageHandler_provided_init_features(this_arg: bigint, t
 	return nativeResponseValue;
 }
 /* @internal */
+export interface LDKOnionMessageProvider {
+	next_onion_message_for_peer (peer_node_id: number): bigint;
+}
+
+/* @internal */
+export function LDKOnionMessageProvider_new(impl: LDKOnionMessageProvider): [bigint, number] {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	var new_obj_idx = js_objs.length;
+	for (var i = 0; i < js_objs.length; i++) {
+		if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+	}
+	js_objs[i] = new WeakRef(impl);
+	return [wasm.TS_LDKOnionMessageProvider_new(i), i];
+}
+	// LDKOnionMessage OnionMessageProvider_next_onion_message_for_peer LDKOnionMessageProvider *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
+/* @internal */
+export function OnionMessageProvider_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_OnionMessageProvider_next_onion_message_for_peer(this_arg, peer_node_id);
+	return nativeResponseValue;
+}
+/* @internal */
 export interface LDKOnionMessageHandler {
 	handle_onion_message (peer_node_id: number, msg: bigint): void;
 	peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
@@ -7917,6 +8191,34 @@ export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): b
 	return nativeResponseValue;
 }
 /* @internal */
+export class LDKHints {
+	protected constructor() {}
+}
+/* @internal */
+export function LDKHints_ty_from_ptr(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKHints_ty_from_ptr(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKHints_Blinded_get_blinded(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKHints_Blinded_get_blinded(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
+export function LDKHints_Clear_get_clear(ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LDKHints_Clear_get_clear(ptr);
+	return nativeResponseValue;
+}
+/* @internal */
 export class LDKDestination {
 	protected constructor() {}
 }
@@ -8170,6 +8472,105 @@ export function Str_free(_res: number): void {
 	}
 	const nativeResponseValue = wasm.TS_Str_free(_res);
 	// debug statements here
+}
+	// struct LDKCOption_DurationZ COption_DurationZ_some(uint64_t o);
+/* @internal */
+export function COption_DurationZ_some(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_DurationZ_some(o);
+	return nativeResponseValue;
+}
+	// struct LDKCOption_DurationZ COption_DurationZ_none(void);
+/* @internal */
+export function COption_DurationZ_none(): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_DurationZ_none();
+	return nativeResponseValue;
+}
+	// void COption_DurationZ_free(struct LDKCOption_DurationZ _res);
+/* @internal */
+export function COption_DurationZ_free(_res: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_DurationZ_free(_res);
+	// debug statements here
+}
+	// uint64_t COption_DurationZ_clone_ptr(LDKCOption_DurationZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_DurationZ_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_DurationZ_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKCOption_DurationZ COption_DurationZ_clone(const struct LDKCOption_DurationZ *NONNULL_PTR orig);
+/* @internal */
+export function COption_DurationZ_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_DurationZ_clone(orig);
+	return nativeResponseValue;
+}
+	// void CVec_BlindedPathZ_free(struct LDKCVec_BlindedPathZ _res);
+/* @internal */
+export function CVec_BlindedPathZ_free(_res: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CVec_BlindedPathZ_free(_res);
+	// debug statements here
+}
+	// struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
+/* @internal */
+export function COption_u64Z_some(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
+	return nativeResponseValue;
+}
+	// struct LDKCOption_u64Z COption_u64Z_none(void);
+/* @internal */
+export function COption_u64Z_none(): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_u64Z_none();
+	return nativeResponseValue;
+}
+	// void COption_u64Z_free(struct LDKCOption_u64Z _res);
+/* @internal */
+export function COption_u64Z_free(_res: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
+	// debug statements here
+}
+	// uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
+/* @internal */
+export function COption_u64Z_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
+/* @internal */
+export function COption_u64Z_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
+	return nativeResponseValue;
 }
 	// struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
 /* @internal */
@@ -8242,6 +8643,114 @@ export function CVec_APIErrorZ_free(_res: number): void {
 	}
 	const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
 	// debug statements here
+}
+	// void CVec_u8Z_free(struct LDKCVec_u8Z _res);
+/* @internal */
+export function CVec_u8Z_free(_res: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
+	// debug statements here
+}
+	// struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_some(struct LDKCVec_u8Z o);
+/* @internal */
+export function COption_CVec_u8ZZ_some(o: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_some(o);
+	return nativeResponseValue;
+}
+	// struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_none(void);
+/* @internal */
+export function COption_CVec_u8ZZ_none(): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_none();
+	return nativeResponseValue;
+}
+	// void COption_CVec_u8ZZ_free(struct LDKCOption_CVec_u8ZZ _res);
+/* @internal */
+export function COption_CVec_u8ZZ_free(_res: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_free(_res);
+	// debug statements here
+}
+	// uint64_t COption_CVec_u8ZZ_clone_ptr(LDKCOption_CVec_u8ZZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_clone(const struct LDKCOption_CVec_u8ZZ *NONNULL_PTR orig);
+/* @internal */
+export function COption_CVec_u8ZZ_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone(orig);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_ok(struct LDKRecipientOnionFields o);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_ok(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok(o);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_err(e: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_err(e);
+	return nativeResponseValue;
+}
+	// bool CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o);
+	return nativeResponseValue;
+}
+	// void CResult_RecipientOnionFieldsDecodeErrorZ_free(struct LDKCResult_RecipientOnionFieldsDecodeErrorZ _res);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_free(_res: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_free(_res);
+	// debug statements here
+}
+	// uint64_t CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_clone(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig);
+	return nativeResponseValue;
 }
 	// struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_some(enum LDKHTLCClaim o);
 /* @internal */
@@ -9125,175 +9634,58 @@ export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: bigint)
 	const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
 	return nativeResponseValue;
 }
-	// void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
+	// struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_ok(struct LDKBlindedPayInfo o);
 /* @internal */
-export function CVec_PublicKeyZ_free(_res: number): void {
+export function CResult_BlindedPayInfoDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
-	// debug statements here
-}
-	// struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_ok(struct LDKBlindedPath o);
-/* @internal */
-export function CResult_BlindedPathNoneZ_ok(o: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_err(void);
+	// struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_BlindedPathNoneZ_err(): bigint {
+export function CResult_BlindedPayInfoDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_err();
+	const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_BlindedPathNoneZ_is_ok(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR o);
+	// bool CResult_BlindedPayInfoDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_BlindedPathNoneZ_is_ok(o: bigint): boolean {
+export function CResult_BlindedPayInfoDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_BlindedPathNoneZ_free(struct LDKCResult_BlindedPathNoneZ _res);
+	// void CResult_BlindedPayInfoDecodeErrorZ_free(struct LDKCResult_BlindedPayInfoDecodeErrorZ _res);
 /* @internal */
-export function CResult_BlindedPathNoneZ_free(_res: bigint): void {
+export function CResult_BlindedPayInfoDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_BlindedPathNoneZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_clone(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR orig);
+	// uint64_t CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_BlindedPathNoneZ_clone(orig: bigint): bigint {
+export function CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_ok(struct LDKBlindedPath o);
+	// struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_clone(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_BlindedPathDecodeErrorZ_ok(o: bigint): bigint {
+export function CResult_BlindedPayInfoDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_ok(o);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_BlindedPathDecodeErrorZ_err(e: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_err(e);
-	return nativeResponseValue;
-}
-	// bool CResult_BlindedPathDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_BlindedPathDecodeErrorZ_is_ok(o: bigint): boolean {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_is_ok(o);
-	return nativeResponseValue;
-}
-	// void CResult_BlindedPathDecodeErrorZ_free(struct LDKCResult_BlindedPathDecodeErrorZ _res);
-/* @internal */
-export function CResult_BlindedPathDecodeErrorZ_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_free(_res);
-	// debug statements here
-}
-	// uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_BlindedPathDecodeErrorZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_clone(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_BlindedPathDecodeErrorZ_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone(orig);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_ok(struct LDKBlindedHop o);
-/* @internal */
-export function CResult_BlindedHopDecodeErrorZ_ok(o: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_ok(o);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_BlindedHopDecodeErrorZ_err(e: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_err(e);
-	return nativeResponseValue;
-}
-	// bool CResult_BlindedHopDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_BlindedHopDecodeErrorZ_is_ok(o: bigint): boolean {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_is_ok(o);
-	return nativeResponseValue;
-}
-	// void CResult_BlindedHopDecodeErrorZ_free(struct LDKCResult_BlindedHopDecodeErrorZ _res);
-/* @internal */
-export function CResult_BlindedHopDecodeErrorZ_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_free(_res);
-	// debug statements here
-}
-	// uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_BlindedHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_clone(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_BlindedHopDecodeErrorZ_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
 	// void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
@@ -9358,60 +9750,6 @@ export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
 	}
 	const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
 	return nativeResponseValue;
-}
-	// void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
-/* @internal */
-export function CVec_RouteHopZ_free(_res: number): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
-	// debug statements here
-}
-	// struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
-/* @internal */
-export function COption_u64Z_some(o: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
-	return nativeResponseValue;
-}
-	// struct LDKCOption_u64Z COption_u64Z_none(void);
-/* @internal */
-export function COption_u64Z_none(): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_COption_u64Z_none();
-	return nativeResponseValue;
-}
-	// void COption_u64Z_free(struct LDKCOption_u64Z _res);
-/* @internal */
-export function COption_u64Z_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
-	// debug statements here
-}
-	// uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
-/* @internal */
-export function COption_u64Z_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
-/* @internal */
-export function COption_u64Z_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
-	return nativeResponseValue;
 }
 	// struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
 /* @internal */
@@ -9521,13 +9859,85 @@ export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
 	const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
+	// void CVec_BlindedHopZ_free(struct LDKCVec_BlindedHopZ _res);
+/* @internal */
+export function CVec_BlindedHopZ_free(_res: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CVec_BlindedHopZ_free(_res);
+	// debug statements here
+}
+	// struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_ok(struct LDKBlindedTail o);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_ok(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_ok(o);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_err(e: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_err(e);
+	return nativeResponseValue;
+}
+	// bool CResult_BlindedTailDecodeErrorZ_is_ok(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_is_ok(o: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_is_ok(o);
+	return nativeResponseValue;
+}
+	// void CResult_BlindedTailDecodeErrorZ_free(struct LDKCResult_BlindedTailDecodeErrorZ _res);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_free(_res: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_free(_res);
+	// debug statements here
+}
+	// uint64_t CResult_BlindedTailDecodeErrorZ_clone_ptr(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_clone(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone(orig);
+	return nativeResponseValue;
+}
+	// void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
+/* @internal */
+export function CVec_RouteHopZ_free(_res: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
+	// debug statements here
+}
+	// void CVec_PathZ_free(struct LDKCVec_PathZ _res);
 /* @internal */
-export function CVec_CVec_RouteHopZZ_free(_res: number): void {
+export function CVec_PathZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
+	const nativeResponseValue = wasm.TS_CVec_PathZ_free(_res);
 	// debug statements here
 }
 	// struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
@@ -9637,15 +10047,6 @@ export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint
 	}
 	const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
-}
-	// void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
-/* @internal */
-export function CVec_RouteHintZ_free(_res: number): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
-	// debug statements here
 }
 	// void CVec_u64Z_free(struct LDKCVec_u64Z _res);
 /* @internal */
@@ -9709,6 +10110,60 @@ export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigin
 	}
 	const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
+}
+	// uint64_t C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR arg);
+/* @internal */
+export function C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_clone(const struct LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR orig);
+/* @internal */
+export function C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig);
+	return nativeResponseValue;
+}
+	// struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_new(struct LDKBlindedPayInfo a, struct LDKBlindedPath b);
+/* @internal */
+export function C2Tuple_BlindedPayInfoBlindedPathZ_new(a: bigint, b: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_new(a, b);
+	return nativeResponseValue;
+}
+	// void C2Tuple_BlindedPayInfoBlindedPathZ_free(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ _res);
+/* @internal */
+export function C2Tuple_BlindedPayInfoBlindedPathZ_free(_res: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_free(_res);
+	// debug statements here
+}
+	// void CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ _res);
+/* @internal */
+export function CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res);
+	// debug statements here
+}
+	// void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
+/* @internal */
+export function CVec_RouteHintZ_free(_res: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
+	// debug statements here
 }
 	// void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
 /* @internal */
@@ -9827,1327 +10282,1498 @@ export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
 	const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
+	// void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
 /* @internal */
-export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
+export function CVec_PublicKeyZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
+	// debug statements here
+}
+	// uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
+/* @internal */
+export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
+export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
 	return nativeResponseValue;
 }
-	// bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
+	// struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
 /* @internal */
-export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
+export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
 	return nativeResponseValue;
 }
-	// void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
+	// void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
 /* @internal */
-export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
+export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
+	// void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
 /* @internal */
-export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
+	// debug statements here
 }
-	// struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
+	// uint64_t C2Tuple_TxidBlockHashZ_clone_ptr(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
+export function C2Tuple_TxidBlockHashZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
+	// struct LDKC2Tuple_TxidBlockHashZ C2Tuple_TxidBlockHashZ_clone(const struct LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR orig);
 /* @internal */
-export function COption_NetworkUpdateZ_some(o: bigint): bigint {
+export function C2Tuple_TxidBlockHashZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
+	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
+	// struct LDKC2Tuple_TxidBlockHashZ C2Tuple_TxidBlockHashZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
 /* @internal */
-export function COption_NetworkUpdateZ_none(): bigint {
+export function C2Tuple_TxidBlockHashZ_new(a: number, b: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
+	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_new(a, b);
 	return nativeResponseValue;
 }
-	// void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
+	// void C2Tuple_TxidBlockHashZ_free(struct LDKC2Tuple_TxidBlockHashZ _res);
 /* @internal */
-export function COption_NetworkUpdateZ_free(_res: bigint): void {
+export function C2Tuple_TxidBlockHashZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
+	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_free(_res);
 	// debug statements here
 }
-	// uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
+	// void CVec_C2Tuple_TxidBlockHashZZ_free(struct LDKCVec_C2Tuple_TxidBlockHashZZ _res);
 /* @internal */
-export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
+export function CVec_C2Tuple_TxidBlockHashZZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidBlockHashZZ_free(_res);
+	// debug statements here
 }
-	// struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
+	// void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
 /* @internal */
-export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
+export function CVec_MonitorEventZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
+	// debug statements here
 }
-	// struct LDKCOption_PathFailureZ COption_PathFailureZ_some(struct LDKPathFailure o);
+	// uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
 /* @internal */
-export function COption_PathFailureZ_some(o: bigint): bigint {
+export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_PathFailureZ_some(o);
+	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_PathFailureZ COption_PathFailureZ_none(void);
+	// struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
 /* @internal */
-export function COption_PathFailureZ_none(): bigint {
+export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_PathFailureZ_none();
+	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
 	return nativeResponseValue;
 }
-	// void COption_PathFailureZ_free(struct LDKCOption_PathFailureZ _res);
+	// struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
 /* @internal */
-export function COption_PathFailureZ_free(_res: bigint): void {
+export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_PathFailureZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
+	return nativeResponseValue;
 }
-	// uint64_t COption_PathFailureZ_clone_ptr(LDKCOption_PathFailureZ *NONNULL_PTR arg);
+	// void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
 /* @internal */
-export function COption_PathFailureZ_clone_ptr(arg: bigint): bigint {
+export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone_ptr(arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
+	// debug statements here
 }
-	// struct LDKCOption_PathFailureZ COption_PathFailureZ_clone(const struct LDKCOption_PathFailureZ *NONNULL_PTR orig);
+	// void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
 /* @internal */
-export function COption_PathFailureZ_clone(orig: bigint): bigint {
+export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
+	// debug statements here
 }
-	// struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_ok(struct LDKCOption_PathFailureZ o);
+	// struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
 /* @internal */
-export function CResult_COption_PathFailureZDecodeErrorZ_ok(o: bigint): bigint {
+export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_COption_PathFailureZDecodeErrorZ_err(e: bigint): bigint {
+export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_COption_PathFailureZDecodeErrorZ_is_ok(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR o);
+	// bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_COption_PathFailureZDecodeErrorZ_is_ok(o: bigint): boolean {
+export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_COption_PathFailureZDecodeErrorZ_free(struct LDKCResult_COption_PathFailureZDecodeErrorZ _res);
+	// void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
 /* @internal */
-export function CResult_COption_PathFailureZDecodeErrorZ_free(_res: bigint): void {
+export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR arg);
+	// uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_clone(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR orig);
+	// struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_COption_PathFailureZDecodeErrorZ_clone(orig: bigint): bigint {
+export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
+	// uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
 /* @internal */
-export function COption_ClosureReasonZ_some(o: bigint): bigint {
+export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
+	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
+	// struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
 /* @internal */
-export function COption_ClosureReasonZ_none(): bigint {
+export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
+	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
 	return nativeResponseValue;
 }
-	// void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
+	// struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
 /* @internal */
-export function COption_ClosureReasonZ_free(_res: bigint): void {
+export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
+	return nativeResponseValue;
 }
-	// uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
+	// void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
 /* @internal */
-export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
+export function C2Tuple_u64u64Z_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
+	// debug statements here
 }
-	// struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
+	// struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
 /* @internal */
-export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
+export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
+	const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
+	// struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
 /* @internal */
-export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
+export function COption_C2Tuple_u64u64ZZ_none(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
+	// void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
 /* @internal */
-export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
+export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
+	// debug statements here
 }
-	// bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
+	// uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
+export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
+	// struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
+export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
+	return nativeResponseValue;
 }
-	// uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
+	// uint64_t C2Tuple_Z_clone_ptr(LDKC2Tuple_Z *NONNULL_PTR arg);
 /* @internal */
-export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+export function C2Tuple_Z_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_C2Tuple_Z_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
+	// struct LDKC2Tuple_Z C2Tuple_Z_clone(const struct LDKC2Tuple_Z *NONNULL_PTR orig);
 /* @internal */
-export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
+export function C2Tuple_Z_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_C2Tuple_Z_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
+	// struct LDKC2Tuple_Z C2Tuple_Z_new(struct LDKEightU16s a, struct LDKEightU16s b);
 /* @internal */
-export function COption_HTLCDestinationZ_some(o: bigint): bigint {
+export function C2Tuple_Z_new(a: number, b: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
+	const nativeResponseValue = wasm.TS_C2Tuple_Z_new(a, b);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
+	// void C2Tuple_Z_free(struct LDKC2Tuple_Z _res);
 /* @internal */
-export function COption_HTLCDestinationZ_none(): bigint {
+export function C2Tuple_Z_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_C2Tuple_Z_free(_res);
+	// debug statements here
 }
-	// void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
+	// uint64_t C2Tuple__u168_u168Z_clone_ptr(LDKC2Tuple__u168_u168Z *NONNULL_PTR arg);
 /* @internal */
-export function COption_HTLCDestinationZ_free(_res: bigint): void {
+export function C2Tuple__u168_u168Z_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_clone_ptr(arg);
+	return nativeResponseValue;
 }
-	// uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
+	// struct LDKC2Tuple__u168_u168Z C2Tuple__u168_u168Z_clone(const struct LDKC2Tuple__u168_u168Z *NONNULL_PTR orig);
 /* @internal */
-export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
+export function C2Tuple__u168_u168Z_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
+	// struct LDKC2Tuple__u168_u168Z C2Tuple__u168_u168Z_new(struct LDKEightU16s a, struct LDKEightU16s b);
 /* @internal */
-export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
+export function C2Tuple__u168_u168Z_new(a: number, b: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
+	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_new(a, b);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
+	// void C2Tuple__u168_u168Z_free(struct LDKC2Tuple__u168_u168Z _res);
 /* @internal */
-export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
+export function C2Tuple__u168_u168Z_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_free(_res);
+	// debug statements here
 }
-	// struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_some(struct LDKC2Tuple__u168_u168Z o);
 /* @internal */
-export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
+export function COption_C2Tuple_EightU16sEightU16sZZ_some(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_some(o);
 	return nativeResponseValue;
 }
-	// bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
+	// struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_none(void);
 /* @internal */
-export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
+export function COption_C2Tuple_EightU16sEightU16sZZ_none(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_none();
 	return nativeResponseValue;
 }
-	// void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
+	// void COption_C2Tuple_EightU16sEightU16sZZ_free(struct LDKCOption_C2Tuple_EightU16sEightU16sZZ _res);
 /* @internal */
-export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
+export function COption_C2Tuple_EightU16sEightU16sZZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
+	// uint64_t COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(LDKCOption_C2Tuple_EightU16sEightU16sZZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+export function COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
+	// struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_clone(const struct LDKCOption_C2Tuple_EightU16sEightU16sZZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
+export function COption_C2Tuple_EightU16sEightU16sZZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_u128Z COption_u128Z_some(struct LDKU128 o);
+	// void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
 /* @internal */
-export function COption_u128Z_some(o: number): bigint {
+export function CVec_NodeIdZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_u128Z_some(o);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
+	// debug statements here
 }
-	// struct LDKCOption_u128Z COption_u128Z_none(void);
+	// struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
 /* @internal */
-export function COption_u128Z_none(): bigint {
+export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_u128Z_none();
+	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// void COption_u128Z_free(struct LDKCOption_u128Z _res);
+	// struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function COption_u128Z_free(_res: bigint): void {
+export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_u128Z_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
+	return nativeResponseValue;
 }
-	// uint64_t COption_u128Z_clone_ptr(LDKCOption_u128Z *NONNULL_PTR arg);
+	// bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function COption_u128Z_clone_ptr(arg: bigint): bigint {
+export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_u128Z_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_u128Z COption_u128Z_clone(const struct LDKCOption_u128Z *NONNULL_PTR orig);
+	// void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
 /* @internal */
-export function COption_u128Z_clone(orig: bigint): bigint {
+export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_u128Z_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
+	// debug statements here
 }
-	// void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
+	// struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
 /* @internal */
-export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
+export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
+	return nativeResponseValue;
 }
-	// struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
+	// struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function COption_EventZ_some(o: bigint): bigint {
+export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
+	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_EventZ COption_EventZ_none(void);
+	// bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function COption_EventZ_none(): bigint {
+export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_EventZ_none();
+	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void COption_EventZ_free(struct LDKCOption_EventZ _res);
+	// void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
 /* @internal */
-export function COption_EventZ_free(_res: bigint): void {
+export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
+	// uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function COption_EventZ_clone_ptr(arg: bigint): bigint {
+export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
+	// struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function COption_EventZ_clone(orig: bigint): bigint {
+export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
+	// struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
 /* @internal */
-export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
+export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
+export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
+	// bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
+export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
+	// void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
 /* @internal */
-export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
+export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
+	// uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
+	// struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
+export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
+	// struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
 /* @internal */
-export function CVec_MessageSendEventZ_free(_res: number): void {
+export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
+	return nativeResponseValue;
 }
-	// uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
+	// struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
+export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
+	// bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
+export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
+	// void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
 /* @internal */
-export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
+export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
+	// debug statements here
 }
-	// void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
+	// uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
+export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
+	return nativeResponseValue;
 }
-	// void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
+	// struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
+export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
+	return nativeResponseValue;
 }
-	// uint64_t C2Tuple_TxidBlockHashZ_clone_ptr(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR arg);
+	// struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
 /* @internal */
-export function C2Tuple_TxidBlockHashZ_clone_ptr(arg: bigint): bigint {
+export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKC2Tuple_TxidBlockHashZ C2Tuple_TxidBlockHashZ_clone(const struct LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR orig);
+	// struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function C2Tuple_TxidBlockHashZ_clone(orig: bigint): bigint {
+export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKC2Tuple_TxidBlockHashZ C2Tuple_TxidBlockHashZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
+	// bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function C2Tuple_TxidBlockHashZ_new(a: number, b: number): bigint {
+export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_new(a, b);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void C2Tuple_TxidBlockHashZ_free(struct LDKC2Tuple_TxidBlockHashZ _res);
+	// void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
 /* @internal */
-export function C2Tuple_TxidBlockHashZ_free(_res: bigint): void {
+export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_TxidBlockHashZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// void CVec_C2Tuple_TxidBlockHashZZ_free(struct LDKCVec_C2Tuple_TxidBlockHashZZ _res);
+	// uint64_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CVec_C2Tuple_TxidBlockHashZZ_free(_res: number): void {
+export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidBlockHashZZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
+	return nativeResponseValue;
 }
-	// void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
+	// struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CVec_MonitorEventZ_free(_res: number): void {
+export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
+	return nativeResponseValue;
 }
-	// uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
+	// struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_ok(struct LDKBlindedHopFeatures o);
 /* @internal */
-export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
+export function CResult_BlindedHopFeaturesDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
+	// struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
+export function CResult_BlindedHopFeaturesDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
+	// bool CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
+export function CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
+	// void CResult_BlindedHopFeaturesDecodeErrorZ_free(struct LDKCResult_BlindedHopFeaturesDecodeErrorZ _res);
 /* @internal */
-export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
+export function CResult_BlindedHopFeaturesDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
+	// uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
+export function CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg);
+	return nativeResponseValue;
 }
-	// struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
+	// struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_clone(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
+export function CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
 /* @internal */
-export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
+	// struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
+	// bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
+	return nativeResponseValue;
+}
+	// void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
+/* @internal */
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
+	// uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
+	// struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
+	// struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
 /* @internal */
-export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
+export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
+	// struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
+export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
+	// bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
+export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
+	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
+	// void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
 /* @internal */
-export function C2Tuple_u64u64Z_free(_res: bigint): void {
+export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
+	// uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
+export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
+	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
+	// struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function COption_C2Tuple_u64u64ZZ_none(): bigint {
+export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
+	const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
+	// struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
 /* @internal */
-export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
+export function COption_NetworkUpdateZ_some(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
+	return nativeResponseValue;
 }
-	// uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
+	// struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
 /* @internal */
-export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
+export function COption_NetworkUpdateZ_none(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
 	return nativeResponseValue;
 }
-	// struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
+	// void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
 /* @internal */
-export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
+export function COption_NetworkUpdateZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
+	// debug statements here
 }
-	// uint64_t C2Tuple_Z_clone_ptr(LDKC2Tuple_Z *NONNULL_PTR arg);
+	// uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
 /* @internal */
-export function C2Tuple_Z_clone_ptr(arg: bigint): bigint {
+export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_Z_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKC2Tuple_Z C2Tuple_Z_clone(const struct LDKC2Tuple_Z *NONNULL_PTR orig);
+	// struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
 /* @internal */
-export function C2Tuple_Z_clone(orig: bigint): bigint {
+export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_Z_clone(orig);
+	const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKC2Tuple_Z C2Tuple_Z_new(struct LDKEightU16s a, struct LDKEightU16s b);
+	// struct LDKCOption_PathFailureZ COption_PathFailureZ_some(struct LDKPathFailure o);
 /* @internal */
-export function C2Tuple_Z_new(a: number, b: number): bigint {
+export function COption_PathFailureZ_some(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_Z_new(a, b);
+	const nativeResponseValue = wasm.TS_COption_PathFailureZ_some(o);
 	return nativeResponseValue;
 }
-	// void C2Tuple_Z_free(struct LDKC2Tuple_Z _res);
+	// struct LDKCOption_PathFailureZ COption_PathFailureZ_none(void);
 /* @internal */
-export function C2Tuple_Z_free(_res: bigint): void {
+export function COption_PathFailureZ_none(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple_Z_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_COption_PathFailureZ_none();
+	return nativeResponseValue;
 }
-	// uint64_t C2Tuple__u168_u168Z_clone_ptr(LDKC2Tuple__u168_u168Z *NONNULL_PTR arg);
+	// void COption_PathFailureZ_free(struct LDKCOption_PathFailureZ _res);
 /* @internal */
-export function C2Tuple__u168_u168Z_clone_ptr(arg: bigint): bigint {
+export function COption_PathFailureZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_clone_ptr(arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_COption_PathFailureZ_free(_res);
+	// debug statements here
 }
-	// struct LDKC2Tuple__u168_u168Z C2Tuple__u168_u168Z_clone(const struct LDKC2Tuple__u168_u168Z *NONNULL_PTR orig);
+	// uint64_t COption_PathFailureZ_clone_ptr(LDKCOption_PathFailureZ *NONNULL_PTR arg);
 /* @internal */
-export function C2Tuple__u168_u168Z_clone(orig: bigint): bigint {
+export function COption_PathFailureZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_clone(orig);
+	const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKC2Tuple__u168_u168Z C2Tuple__u168_u168Z_new(struct LDKEightU16s a, struct LDKEightU16s b);
+	// struct LDKCOption_PathFailureZ COption_PathFailureZ_clone(const struct LDKCOption_PathFailureZ *NONNULL_PTR orig);
 /* @internal */
-export function C2Tuple__u168_u168Z_new(a: number, b: number): bigint {
+export function COption_PathFailureZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_new(a, b);
+	const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone(orig);
 	return nativeResponseValue;
 }
-	// void C2Tuple__u168_u168Z_free(struct LDKC2Tuple__u168_u168Z _res);
+	// struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_ok(struct LDKCOption_PathFailureZ o);
 /* @internal */
-export function C2Tuple__u168_u168Z_free(_res: bigint): void {
+export function CResult_COption_PathFailureZDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_ok(o);
+	return nativeResponseValue;
 }
-	// struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_some(struct LDKC2Tuple__u168_u168Z o);
+	// struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function COption_C2Tuple_EightU16sEightU16sZZ_some(o: bigint): bigint {
+export function CResult_COption_PathFailureZDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_some(o);
+	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_none(void);
+	// bool CResult_COption_PathFailureZDecodeErrorZ_is_ok(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function COption_C2Tuple_EightU16sEightU16sZZ_none(): bigint {
+export function CResult_COption_PathFailureZDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_none();
+	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void COption_C2Tuple_EightU16sEightU16sZZ_free(struct LDKCOption_C2Tuple_EightU16sEightU16sZZ _res);
+	// void CResult_COption_PathFailureZDecodeErrorZ_free(struct LDKCResult_COption_PathFailureZDecodeErrorZ _res);
 /* @internal */
-export function COption_C2Tuple_EightU16sEightU16sZZ_free(_res: bigint): void {
+export function CResult_COption_PathFailureZDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(LDKCOption_C2Tuple_EightU16sEightU16sZZ *NONNULL_PTR arg);
+	// uint64_t CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(arg: bigint): bigint {
+export function CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_clone(const struct LDKCOption_C2Tuple_EightU16sEightU16sZZ *NONNULL_PTR orig);
+	// struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_clone(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function COption_C2Tuple_EightU16sEightU16sZZ_clone(orig: bigint): bigint {
+export function CResult_COption_PathFailureZDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
+	// struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
 /* @internal */
-export function CVec_NodeIdZ_free(_res: number): void {
+export function COption_ClosureReasonZ_some(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
+	return nativeResponseValue;
 }
-	// struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
+	// struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
 /* @internal */
-export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
+export function COption_ClosureReasonZ_none(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
 	return nativeResponseValue;
 }
-	// struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
+	// void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
 /* @internal */
-export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
+export function COption_ClosureReasonZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
+	// debug statements here
 }
-	// bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
+	// uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
+export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
+	// struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
+export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
+	return nativeResponseValue;
 }
-	// struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
+	// struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
 /* @internal */
-export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
+export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
+	// bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
+	// void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
 /* @internal */
-export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
+export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
+	// uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
+	// struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
 /* @internal */
-export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
+export function COption_HTLCDestinationZ_some(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
 	return nativeResponseValue;
 }
-	// bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
+	// struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
 /* @internal */
-export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+export function COption_HTLCDestinationZ_none(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
 	return nativeResponseValue;
 }
-	// void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
+	// void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
 /* @internal */
-export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
+export function COption_HTLCDestinationZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
+	// uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
+	// struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
+	// struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
 /* @internal */
-export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
+export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
+	// bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
+	// void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
 /* @internal */
-export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
+export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
+	// uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
+	// struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
+	// struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_ok(enum LDKPaymentFailureReason o);
 /* @internal */
-export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+export function CResult_PaymentFailureReasonDecodeErrorZ_ok(o: PaymentFailureReason): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
+export function CResult_PaymentFailureReasonDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
+	// bool CResult_PaymentFailureReasonDecodeErrorZ_is_ok(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+export function CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
+	// void CResult_PaymentFailureReasonDecodeErrorZ_free(struct LDKCResult_PaymentFailureReasonDecodeErrorZ _res);
 /* @internal */
-export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
+export function CResult_PaymentFailureReasonDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
+	// uint64_t CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
+	// struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_clone(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+export function CResult_PaymentFailureReasonDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_ok(struct LDKBlindedHopFeatures o);
+	// struct LDKCOption_u128Z COption_u128Z_some(struct LDKU128 o);
 /* @internal */
-export function CResult_BlindedHopFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+export function COption_u128Z_some(o: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_COption_u128Z_some(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKCOption_u128Z COption_u128Z_none(void);
 /* @internal */
-export function CResult_BlindedHopFeaturesDecodeErrorZ_err(e: bigint): bigint {
+export function COption_u128Z_none(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_COption_u128Z_none();
 	return nativeResponseValue;
 }
-	// bool CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR o);
+	// void COption_u128Z_free(struct LDKCOption_u128Z _res);
 /* @internal */
-export function CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+export function COption_u128Z_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_COption_u128Z_free(_res);
+	// debug statements here
+}
+	// uint64_t COption_u128Z_clone_ptr(LDKCOption_u128Z *NONNULL_PTR arg);
+/* @internal */
+export function COption_u128Z_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_u128Z_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void CResult_BlindedHopFeaturesDecodeErrorZ_free(struct LDKCResult_BlindedHopFeaturesDecodeErrorZ _res);
+	// struct LDKCOption_u128Z COption_u128Z_clone(const struct LDKCOption_u128Z *NONNULL_PTR orig);
 /* @internal */
-export function CResult_BlindedHopFeaturesDecodeErrorZ_free(_res: bigint): void {
+export function COption_u128Z_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_COption_u128Z_clone(orig);
+	return nativeResponseValue;
+}
+	// struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_some(enum LDKPaymentFailureReason o);
+/* @internal */
+export function COption_PaymentFailureReasonZ_some(o: PaymentFailureReason): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_some(o);
+	return nativeResponseValue;
+}
+	// struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_none(void);
+/* @internal */
+export function COption_PaymentFailureReasonZ_none(): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_none();
+	return nativeResponseValue;
+}
+	// void COption_PaymentFailureReasonZ_free(struct LDKCOption_PaymentFailureReasonZ _res);
+/* @internal */
+export function COption_PaymentFailureReasonZ_free(_res: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg);
+	// uint64_t COption_PaymentFailureReasonZ_clone_ptr(LDKCOption_PaymentFailureReasonZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+export function COption_PaymentFailureReasonZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_clone(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR orig);
+	// struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_clone(const struct LDKCOption_PaymentFailureReasonZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+export function COption_PaymentFailureReasonZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
+	// void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
 /* @internal */
-export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
+	// debug statements here
+}
+	// struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
+/* @internal */
+export function COption_EventZ_some(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKCOption_EventZ COption_EventZ_none(void);
 /* @internal */
-export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
+export function COption_EventZ_none(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_COption_EventZ_none();
 	return nativeResponseValue;
 }
-	// bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
+	// void COption_EventZ_free(struct LDKCOption_EventZ _res);
 /* @internal */
-export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+export function COption_EventZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
+	// debug statements here
+}
+	// uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_EventZ_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
+	// struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
+export function COption_EventZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
+/* @internal */
+export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
+	return nativeResponseValue;
+}
+	// bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
+	return nativeResponseValue;
+}
+	// void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
+/* @internal */
+export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
+	// uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
+	// struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
+	return nativeResponseValue;
+}
+	// void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
+/* @internal */
+export function CVec_MessageSendEventZ_free(_res: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
+	// debug statements here
+}
+	// void CVec_ChainHashZ_free(struct LDKCVec_ChainHashZ _res);
+/* @internal */
+export function CVec_ChainHashZ_free(_res: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CVec_ChainHashZ_free(_res);
+	// debug statements here
+}
+	// struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
+/* @internal */
+export function CResult_PublicKeyErrorZ_ok(o: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
+/* @internal */
+export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
+	return nativeResponseValue;
+}
+	// bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_PublicKeyErrorZ_is_ok(o: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
+	return nativeResponseValue;
+}
+	// void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
+/* @internal */
+export function CResult_PublicKeyErrorZ_free(_res: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
+	// debug statements here
+}
+	// uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_PublicKeyErrorZ_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_PublicKeyErrorZ_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
 	return nativeResponseValue;
 }
 	// struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
@@ -12454,15 +13080,6 @@ export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig: bigi
 	}
 	const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
-}
-	// void CVec_u8Z_free(struct LDKCVec_u8Z _res);
-/* @internal */
-export function CVec_u8Z_free(_res: number): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
-	// debug statements here
 }
 	// void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
 /* @internal */
@@ -13804,6 +14421,60 @@ export function CResult_COption_APIErrorZDecodeErrorZ_clone(orig: bigint): bigin
 	}
 	const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
+}
+	// struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_ok(struct LDKUntrustedString o);
+/* @internal */
+export function CResult_UntrustedStringDecodeErrorZ_ok(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_ok(o);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_UntrustedStringDecodeErrorZ_err(e: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_err(e);
+	return nativeResponseValue;
+}
+	// bool CResult_UntrustedStringDecodeErrorZ_is_ok(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_UntrustedStringDecodeErrorZ_is_ok(o: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_is_ok(o);
+	return nativeResponseValue;
+}
+	// void CResult_UntrustedStringDecodeErrorZ_free(struct LDKCResult_UntrustedStringDecodeErrorZ _res);
+/* @internal */
+export function CResult_UntrustedStringDecodeErrorZ_free(_res: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_free(_res);
+	// debug statements here
+}
+	// uint64_t CResult_UntrustedStringDecodeErrorZ_clone_ptr(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_clone(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_UntrustedStringDecodeErrorZ_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone(orig);
+	return nativeResponseValue;
 }
 	// struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
 /* @internal */
@@ -14119,60 +14790,6 @@ export function CResult_StringErrorZ_clone(orig: bigint): bigint {
 	}
 	const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
 	return nativeResponseValue;
-}
-	// struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
-/* @internal */
-export function CResult_PublicKeyErrorZ_ok(o: number): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
-/* @internal */
-export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
-	return nativeResponseValue;
-}
-	// bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_PublicKeyErrorZ_is_ok(o: bigint): boolean {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
-	return nativeResponseValue;
-}
-	// void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
-/* @internal */
-export function CResult_PublicKeyErrorZ_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
-	// debug statements here
-}
-	// uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_PublicKeyErrorZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_PublicKeyErrorZ_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
-	return nativeResponseValue;
 }
 	// struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
 /* @internal */
@@ -15200,1017 +15817,648 @@ export function CResult_NoneSendErrorZ_free(_res: bigint): void {
 	const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_free(_res);
 	// debug statements here
 }
-	// struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_ok(uint32_t o);
+	// struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_ok(struct LDKBlindedPath o);
 /* @internal */
-export function CResult_u32GraphSyncErrorZ_ok(o: number): bigint {
+export function CResult_BlindedPathNoneZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_err(struct LDKGraphSyncError e);
+	// struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_err(void);
 /* @internal */
-export function CResult_u32GraphSyncErrorZ_err(e: bigint): bigint {
+export function CResult_BlindedPathNoneZ_err(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_err();
 	return nativeResponseValue;
 }
-	// bool CResult_u32GraphSyncErrorZ_is_ok(const struct LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR o);
+	// bool CResult_BlindedPathNoneZ_is_ok(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_u32GraphSyncErrorZ_is_ok(o: bigint): boolean {
+export function CResult_BlindedPathNoneZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_u32GraphSyncErrorZ_free(struct LDKCResult_u32GraphSyncErrorZ _res);
+	// void CResult_BlindedPathNoneZ_free(struct LDKCResult_BlindedPathNoneZ _res);
 /* @internal */
-export function CResult_u32GraphSyncErrorZ_free(_res: bigint): void {
+export function CResult_BlindedPathNoneZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_free(_res);
 	// debug statements here
 }
-	// struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
+	// uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): bigint {
+export function CResult_BlindedPathNoneZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
+	// struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_clone(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_SiPrefixParseErrorZ_err(e: bigint): bigint {
+export function CResult_BlindedPathNoneZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone(orig);
 	return nativeResponseValue;
 }
-	// bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
+	// struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_ok(struct LDKBlindedPath o);
 /* @internal */
-export function CResult_SiPrefixParseErrorZ_is_ok(o: bigint): boolean {
+export function CResult_BlindedPathDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
+	// struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_SiPrefixParseErrorZ_free(_res: bigint): void {
+export function CResult_BlindedPathDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_err(e);
+	return nativeResponseValue;
 }
-	// uint64_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
+	// bool CResult_BlindedPathDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_BlindedPathDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
+	// void CResult_BlindedPathDecodeErrorZ_free(struct LDKCResult_BlindedPathDecodeErrorZ _res);
 /* @internal */
-export function CResult_SiPrefixParseErrorZ_clone(orig: bigint): bigint {
+export function CResult_BlindedPathDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_free(_res);
+	// debug statements here
 }
-	// struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
+	// uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
+export function CResult_BlindedPathDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
+	// struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_clone(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
+export function CResult_BlindedPathDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
+	// struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_ok(struct LDKBlindedHop o);
 /* @internal */
-export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
+export function CResult_BlindedHopDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
+	// struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
+export function CResult_BlindedHopDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_err(e);
+	return nativeResponseValue;
 }
-	// uint64_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
+	// bool CResult_BlindedHopDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_BlindedHopDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
+	// void CResult_BlindedHopDecodeErrorZ_free(struct LDKCResult_BlindedHopDecodeErrorZ _res);
 /* @internal */
-export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
+export function CResult_BlindedHopDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_free(_res);
+	// debug statements here
 }
-	// struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
+	// uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_SignedRawInvoiceParseErrorZ_ok(o: bigint): bigint {
+export function CResult_BlindedHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
+	// struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_clone(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_SignedRawInvoiceParseErrorZ_err(e: bigint): bigint {
+export function CResult_BlindedHopDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
+	// struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_ok(uint32_t o);
 /* @internal */
-export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: bigint): boolean {
+export function CResult_u32GraphSyncErrorZ_ok(o: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
+	// struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_err(struct LDKGraphSyncError e);
 /* @internal */
-export function CResult_SignedRawInvoiceParseErrorZ_free(_res: bigint): void {
+export function CResult_u32GraphSyncErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_err(e);
+	return nativeResponseValue;
 }
-	// uint64_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
+	// bool CResult_u32GraphSyncErrorZ_is_ok(const struct LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_u32GraphSyncErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
+	// void CResult_u32GraphSyncErrorZ_free(struct LDKCResult_u32GraphSyncErrorZ _res);
 /* @internal */
-export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: bigint): bigint {
+export function CResult_u32GraphSyncErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_free(_res);
+	// debug statements here
 }
-	// uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
+	// struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
 /* @internal */
-export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
+export function CResult_NoneErrorZ_ok(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
 	return nativeResponseValue;
 }
-	// struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
+	// struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
 /* @internal */
-export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: bigint): bigint {
+export function CResult_NoneErrorZ_err(e: IOError): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
+	// bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
 /* @internal */
-export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
+export function CResult_NoneErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
+	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
+	// void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
 /* @internal */
-export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: bigint): void {
+export function CResult_NoneErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
 	// debug statements here
 }
-	// struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
+	// uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_PayeePubKeyErrorZ_ok(o: bigint): bigint {
+export function CResult_NoneErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
+	// struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): bigint {
+export function CResult_NoneErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
+	// struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
 /* @internal */
-export function CResult_PayeePubKeyErrorZ_is_ok(o: bigint): boolean {
+export function CResult_NetAddressDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
-/* @internal */
-export function CResult_PayeePubKeyErrorZ_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
-	// debug statements here
-}
-	// uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
+	// struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_NetAddressDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
+	// bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_PayeePubKeyErrorZ_clone(orig: bigint): bigint {
+export function CResult_NetAddressDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
+	// void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
 /* @internal */
-export function CVec_PrivateRouteZ_free(_res: number): void {
+export function CResult_NetAddressDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
+	// uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
+export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
+	// struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
+export function CResult_NetAddressDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
+	// void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
 /* @internal */
-export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
+export function CVec_UpdateAddHTLCZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
+	// debug statements here
 }
-	// void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
+	// void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
 /* @internal */
-export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
+export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
+	// void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
 /* @internal */
-export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
+export function CVec_UpdateFailHTLCZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
+	// debug statements here
 }
-	// struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
+	// void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
 /* @internal */
-export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
+export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
+	// debug statements here
 }
-	// struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
+	// struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
 /* @internal */
-export function CResult_NoneSemanticErrorZ_ok(): bigint {
+export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
+	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
+	// struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_NoneSemanticErrorZ_err(e: SemanticError): bigint {
+export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
+	// bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_NoneSemanticErrorZ_is_ok(o: bigint): boolean {
+export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
+	// void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
 /* @internal */
-export function CResult_NoneSemanticErrorZ_free(_res: bigint): void {
+export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
+	// uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_NoneSemanticErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
+	// struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_NoneSemanticErrorZ_clone(orig: bigint): bigint {
+export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
+	// struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
 /* @internal */
-export function CResult_InvoiceSemanticErrorZ_ok(o: bigint): bigint {
+export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
+	// struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): bigint {
+export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
+	// bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_InvoiceSemanticErrorZ_is_ok(o: bigint): boolean {
+export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
+	// void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
 /* @internal */
-export function CResult_InvoiceSemanticErrorZ_free(_res: bigint): void {
+export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
+	// uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
+	// struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_InvoiceSemanticErrorZ_clone(orig: bigint): bigint {
+export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
+	// struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
 /* @internal */
-export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
+export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
+	// struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
+export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
+	// bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
+export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
+	// void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
 /* @internal */
-export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
+export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
+	// uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
+	// struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
+export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
+	// struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
 /* @internal */
-export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
+export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
+	// struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
+export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
+	// bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
+export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
+	// void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
 /* @internal */
-export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
+export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
+	// uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
+	// struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
+export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
+	// struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
 /* @internal */
-export function CResult_NoneErrorZ_ok(): bigint {
+export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
+	// struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_NoneErrorZ_err(e: IOError): bigint {
+export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
+	// bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_NoneErrorZ_is_ok(o: bigint): boolean {
+export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
+	// void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
 /* @internal */
-export function CResult_NoneErrorZ_free(_res: bigint): void {
+export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
+	// uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function CResult_NoneErrorZ_clone_ptr(arg: bigint): bigint {
+export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
+	// struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function CResult_NoneErrorZ_clone(orig: bigint): bigint {
+export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
+	// struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
 /* @internal */
-export function CResult_NetAddressDecodeErrorZ_ok(o: bigint): bigint {
+export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
+	// struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
 /* @internal */
-export function CResult_NetAddressDecodeErrorZ_err(e: bigint): bigint {
+export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
+	const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
+	// bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
 /* @internal */
-export function CResult_NetAddressDecodeErrorZ_is_ok(o: bigint): boolean {
+export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
+	const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
+	// void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
 /* @internal */
-export function CResult_NetAddressDecodeErrorZ_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
-	// debug statements here
-}
-	// uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_NetAddressDecodeErrorZ_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
-	return nativeResponseValue;
-}
-	// void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
-/* @internal */
-export function CVec_UpdateAddHTLCZ_free(_res: number): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
-	// debug statements here
-}
-	// void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
-/* @internal */
-export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
-	// debug statements here
-}
-	// void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
-/* @internal */
-export function CVec_UpdateFailHTLCZ_free(_res: number): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
-	// debug statements here
-}
-	// void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
-/* @internal */
-export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
-	// debug statements here
-}
-	// struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
-/* @internal */
-export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
-	return nativeResponseValue;
-}
-	// bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
-	return nativeResponseValue;
-}
-	// void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
-/* @internal */
-export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
-	// debug statements here
-}
-	// uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
-/* @internal */
-export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
-	return nativeResponseValue;
-}
-	// bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
-	return nativeResponseValue;
-}
-	// void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
-/* @internal */
-export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
-	// debug statements here
-}
-	// uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
-/* @internal */
-export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
-	return nativeResponseValue;
-}
-	// bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
-	return nativeResponseValue;
-}
-	// void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
-/* @internal */
-export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
-	// debug statements here
-}
-	// uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
-/* @internal */
-export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
-	return nativeResponseValue;
-}
-	// bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
-	return nativeResponseValue;
-}
-	// void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
-/* @internal */
-export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
-	// debug statements here
-}
-	// uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
-/* @internal */
-export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
-	return nativeResponseValue;
-}
-	// bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
-	return nativeResponseValue;
-}
-	// void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
-/* @internal */
-export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
-	// debug statements here
-}
-	// uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
-/* @internal */
-export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
-	return nativeResponseValue;
-}
-	// bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
-	return nativeResponseValue;
-}
-	// void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
-/* @internal */
-export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
+export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
@@ -17746,69 +17994,6 @@ export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: bigint): b
 	}
 	const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
 	return nativeResponseValue;
-}
-	// void CVec_PhantomRouteHintsZ_free(struct LDKCVec_PhantomRouteHintsZ _res);
-/* @internal */
-export function CVec_PhantomRouteHintsZ_free(_res: number): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CVec_PhantomRouteHintsZ_free(_res);
-	// debug statements here
-}
-	// struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
-/* @internal */
-export function CResult_InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
-/* @internal */
-export function CResult_InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
-	return nativeResponseValue;
-}
-	// bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
-	return nativeResponseValue;
-}
-	// void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
-/* @internal */
-export function CResult_InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
-	// debug statements here
-}
-	// uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
-	return nativeResponseValue;
 }
 	// struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
 /* @internal */
@@ -17936,891 +18121,666 @@ export function CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res: number):
 	const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res);
 	// debug statements here
 }
-	// void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
+	// void CVec_PhantomRouteHintsZ_free(struct LDKCVec_PhantomRouteHintsZ _res);
 /* @internal */
-export function PaymentPurpose_free(this_ptr: bigint): void {
+export function CVec_PhantomRouteHintsZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
+	const nativeResponseValue = wasm.TS_CVec_PhantomRouteHintsZ_free(_res);
 	// debug statements here
 }
-	// uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
+	// struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
 /* @internal */
-export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
+export function CResult_InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
+	// struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
 /* @internal */
-export function PaymentPurpose_clone(orig: bigint): bigint {
+export function CResult_InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
+	// bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
 /* @internal */
-export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): bigint {
+export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
+	// void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
 /* @internal */
-export function PaymentPurpose_spontaneous_payment(a: number): bigint {
+export function CResult_InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
+	// debug statements here
 }
-	// bool PaymentPurpose_eq(const struct LDKPaymentPurpose *NONNULL_PTR a, const struct LDKPaymentPurpose *NONNULL_PTR b);
+	// uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function PaymentPurpose_eq(a: bigint, b: bigint): boolean {
+export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentPurpose_eq(a, b);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
+	// struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function PaymentPurpose_write(obj: bigint): number {
+export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
+	// struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
 /* @internal */
-export function PaymentPurpose_read(ser: number): bigint {
+export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
+	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// void PathFailure_free(struct LDKPathFailure this_ptr);
+	// struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
 /* @internal */
-export function PathFailure_free(this_ptr: bigint): void {
+export function CResult_SiPrefixParseErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PathFailure_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
+	return nativeResponseValue;
 }
-	// uint64_t PathFailure_clone_ptr(LDKPathFailure *NONNULL_PTR arg);
+	// bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
 /* @internal */
-export function PathFailure_clone_ptr(arg: bigint): bigint {
+export function CResult_SiPrefixParseErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PathFailure_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKPathFailure PathFailure_clone(const struct LDKPathFailure *NONNULL_PTR orig);
+	// void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
 /* @internal */
-export function PathFailure_clone(orig: bigint): bigint {
+export function CResult_SiPrefixParseErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PathFailure_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
+	// debug statements here
 }
-	// struct LDKPathFailure PathFailure_initial_send(struct LDKAPIError err);
+	// uint64_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function PathFailure_initial_send(err: bigint): bigint {
+export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PathFailure_initial_send(err);
+	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKPathFailure PathFailure_on_path(struct LDKCOption_NetworkUpdateZ network_update);
+	// struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function PathFailure_on_path(network_update: bigint): bigint {
+export function CResult_SiPrefixParseErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PathFailure_on_path(network_update);
+	const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// bool PathFailure_eq(const struct LDKPathFailure *NONNULL_PTR a, const struct LDKPathFailure *NONNULL_PTR b);
+	// struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
 /* @internal */
-export function PathFailure_eq(a: bigint, b: bigint): boolean {
+export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PathFailure_eq(a, b);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z PathFailure_write(const struct LDKPathFailure *NONNULL_PTR obj);
+	// struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
 /* @internal */
-export function PathFailure_write(obj: bigint): number {
+export function CResult_InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PathFailure_write(obj);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_PathFailureZDecodeErrorZ PathFailure_read(struct LDKu8slice ser);
+	// bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
 /* @internal */
-export function PathFailure_read(ser: number): bigint {
+export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PathFailure_read(ser);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void ClosureReason_free(struct LDKClosureReason this_ptr);
+	// void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
 /* @internal */
-export function ClosureReason_free(this_ptr: bigint): void {
+export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
+	// uint64_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function ClosureReason_clone_ptr(arg: bigint): bigint {
+export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
+	// struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function ClosureReason_clone(orig: bigint): bigint {
+export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
+	// struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
 /* @internal */
-export function ClosureReason_counterparty_force_closed(peer_msg: number): bigint {
+export function CResult_SignedRawInvoiceParseErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
+	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKClosureReason ClosureReason_holder_force_closed(void);
+	// struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
 /* @internal */
-export function ClosureReason_holder_force_closed(): bigint {
+export function CResult_SignedRawInvoiceParseErrorZ_err(e: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
+	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKClosureReason ClosureReason_cooperative_closure(void);
+	// bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
 /* @internal */
-export function ClosureReason_cooperative_closure(): bigint {
+export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
+	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
+	// void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
 /* @internal */
-export function ClosureReason_commitment_tx_confirmed(): bigint {
+export function CResult_SignedRawInvoiceParseErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
+	// debug statements here
 }
-	// struct LDKClosureReason ClosureReason_funding_timed_out(void);
+	// uint64_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function ClosureReason_funding_timed_out(): bigint {
+export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
+	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
+	// struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function ClosureReason_processing_error(err: number): bigint {
+export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
+	const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKClosureReason ClosureReason_disconnected_peer(void);
+	// uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
 /* @internal */
-export function ClosureReason_disconnected_peer(): bigint {
+export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
+	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
+	// struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
 /* @internal */
-export function ClosureReason_outdated_channel_manager(): bigint {
+export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
+	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
 	return nativeResponseValue;
 }
-	// bool ClosureReason_eq(const struct LDKClosureReason *NONNULL_PTR a, const struct LDKClosureReason *NONNULL_PTR b);
+	// struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
 /* @internal */
-export function ClosureReason_eq(a: bigint, b: bigint): boolean {
+export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_eq(a, b);
+	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
+	// void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
 /* @internal */
-export function ClosureReason_write(obj: bigint): number {
+export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
+	// debug statements here
 }
-	// struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
+	// struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
 /* @internal */
-export function ClosureReason_read(ser: number): bigint {
+export function CResult_PayeePubKeyErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
+	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
+	// struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
 /* @internal */
-export function HTLCDestination_free(this_ptr: bigint): void {
+export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
+	return nativeResponseValue;
 }
-	// uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
+	// bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
 /* @internal */
-export function HTLCDestination_clone_ptr(arg: bigint): bigint {
+export function CResult_PayeePubKeyErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
+	// void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
 /* @internal */
-export function HTLCDestination_clone(orig: bigint): bigint {
+export function CResult_PayeePubKeyErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
+	// debug statements here
 }
-	// struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
+	// uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): bigint {
+export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
+	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
+	// struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
+export function CResult_PayeePubKeyErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
+	const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKHTLCDestination HTLCDestination_invalid_forward(uint64_t requested_forward_scid);
+	// void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
 /* @internal */
-export function HTLCDestination_invalid_forward(requested_forward_scid: bigint): bigint {
+export function CVec_PrivateRouteZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_HTLCDestination_invalid_forward(requested_forward_scid);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
+	// debug statements here
 }
-	// struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
+	// struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
 /* @internal */
-export function HTLCDestination_failed_payment(payment_hash: number): bigint {
+export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
+	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// bool HTLCDestination_eq(const struct LDKHTLCDestination *NONNULL_PTR a, const struct LDKHTLCDestination *NONNULL_PTR b);
+	// struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
 /* @internal */
-export function HTLCDestination_eq(a: bigint, b: bigint): boolean {
+export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_HTLCDestination_eq(a, b);
+	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
+	// bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
 /* @internal */
-export function HTLCDestination_write(obj: bigint): number {
+export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
+	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
+	// void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
 /* @internal */
-export function HTLCDestination_read(ser: number): bigint {
+export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
+	// debug statements here
 }
-	// void Event_free(struct LDKEvent this_ptr);
+	// uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function Event_free(this_ptr: bigint): void {
+export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
+	return nativeResponseValue;
 }
-	// uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
+	// struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function Event_clone_ptr(arg: bigint): bigint {
+export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
+	// struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
 /* @internal */
-export function Event_clone(orig: bigint): bigint {
+export function CResult_NoneSemanticErrorZ_ok(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_funding_generation_ready(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t channel_value_satoshis, struct LDKCVec_u8Z output_script, struct LDKU128 user_channel_id);
+	// struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
 /* @internal */
-export function Event_funding_generation_ready(temporary_channel_id: number, counterparty_node_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: number): bigint {
+export function CResult_NoneSemanticErrorZ_err(e: SemanticError): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
+	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_payment_claimable(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose, struct LDKThirtyTwoBytes via_channel_id, struct LDKCOption_u128Z via_user_channel_id);
+	// bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
 /* @internal */
-export function Event_payment_claimable(receiver_node_id: number, payment_hash: number, amount_msat: bigint, purpose: bigint, via_channel_id: number, via_user_channel_id: bigint): bigint {
+export function CResult_NoneSemanticErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_payment_claimable(receiver_node_id, payment_hash, amount_msat, purpose, via_channel_id, via_user_channel_id);
+	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_payment_claimed(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
+	// void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
 /* @internal */
-export function Event_payment_claimed(receiver_node_id: number, payment_hash: number, amount_msat: bigint, purpose: bigint): bigint {
+export function CResult_NoneSemanticErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_payment_claimed(receiver_node_id, payment_hash, amount_msat, purpose);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
+	// debug statements here
 }
-	// struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
+	// uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
+export function CResult_NoneSemanticErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
+	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
+	// struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function Event_payment_failed(payment_id: number, payment_hash: number): bigint {
+export function CResult_NoneSemanticErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
+	const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
+	// struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
 /* @internal */
-export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): bigint {
+export function CResult_InvoiceSemanticErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_payment_path_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, bool payment_failed_permanently, struct LDKPathFailure failure, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id, struct LDKRouteParameters retry);
+	// struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
 /* @internal */
-export function Event_payment_path_failed(payment_id: number, payment_hash: number, payment_failed_permanently: boolean, failure: bigint, path: number, short_channel_id: bigint, retry: bigint): bigint {
+export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, payment_failed_permanently, failure, path, short_channel_id, retry);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
+	// bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
 /* @internal */
-export function Event_probe_successful(payment_id: number, payment_hash: number, path: number): bigint {
+export function CResult_InvoiceSemanticErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id);
+	// void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
 /* @internal */
-export function Event_probe_failed(payment_id: number, payment_hash: number, path: number, short_channel_id: bigint): bigint {
+export function CResult_InvoiceSemanticErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
+	// debug statements here
 }
-	// struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
+	// uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
+export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_htlcintercepted(struct LDKThirtyTwoBytes intercept_id, uint64_t requested_next_hop_scid, struct LDKThirtyTwoBytes payment_hash, uint64_t inbound_amount_msat, uint64_t expected_outbound_amount_msat);
+	// struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function Event_htlcintercepted(intercept_id: number, requested_next_hop_scid: bigint, payment_hash: number, inbound_amount_msat: bigint, expected_outbound_amount_msat: bigint): bigint {
+export function CResult_InvoiceSemanticErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_htlcintercepted(intercept_id, requested_next_hop_scid, payment_hash, inbound_amount_msat, expected_outbound_amount_msat);
+	const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
+	// void CVec_AddressZ_free(struct LDKCVec_AddressZ _res);
 /* @internal */
-export function Event_spendable_outputs(outputs: number): bigint {
+export function CVec_AddressZ_free(_res: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CVec_AddressZ_free(_res);
+	// debug statements here
 }
-	// struct LDKEvent Event_payment_forwarded(struct LDKThirtyTwoBytes prev_channel_id, struct LDKThirtyTwoBytes next_channel_id, struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx);
+	// struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
 /* @internal */
-export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: bigint, claim_from_onchain_tx: boolean): bigint {
+export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
+	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_channel_ready(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKChannelTypeFeatures channel_type);
+	// struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
 /* @internal */
-export function Event_channel_ready(channel_id: number, user_channel_id: number, counterparty_node_id: number, channel_type: bigint): bigint {
+export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_channel_ready(channel_id, user_channel_id, counterparty_node_id, channel_type);
+	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKClosureReason reason);
+	// bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
 /* @internal */
-export function Event_channel_closed(channel_id: number, user_channel_id: number, reason: bigint): bigint {
+export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
+	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
+	// void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
 /* @internal */
-export function Event_discard_funding(channel_id: number, transaction: number): bigint {
+export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
+	// debug statements here
 }
-	// struct LDKEvent Event_open_channel_request(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t funding_satoshis, uint64_t push_msat, struct LDKChannelTypeFeatures channel_type);
+	// uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
+export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
+	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
+	// struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: bigint): bigint {
+export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
+	const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// bool Event_eq(const struct LDKEvent *NONNULL_PTR a, const struct LDKEvent *NONNULL_PTR b);
+	// struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
 /* @internal */
-export function Event_eq(a: bigint, b: bigint): boolean {
+export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_eq(a, b);
+	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
+	// struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
 /* @internal */
-export function Event_write(obj: bigint): number {
+export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_write(obj);
+	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
+	// bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
 /* @internal */
-export function Event_read(ser: number): bigint {
+export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Event_read(ser);
+	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
 	return nativeResponseValue;
 }
-	// void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
+	// void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
 /* @internal */
-export function MessageSendEvent_free(this_ptr: bigint): void {
+export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
+	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
 	// debug statements here
 }
-	// uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
+	// uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
 /* @internal */
-export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
+export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
+	// struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
 /* @internal */
-export function MessageSendEvent_clone(orig: bigint): bigint {
+export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
+	const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
+	// void APIError_free(struct LDKAPIError this_ptr);
 /* @internal */
-export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
+export function APIError_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
+	// debug statements here
 }
-	// struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
+	// uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
 /* @internal */
-export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
+export function APIError_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
+	const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
+	// struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
 /* @internal */
-export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
+export function APIError_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
+	const nativeResponseValue = wasm.TS_APIError_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
+	// struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
 /* @internal */
-export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
+export function APIError_apimisuse_error(err: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
+	const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
 	return nativeResponseValue;
 }
-	// struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
+	// struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
 /* @internal */
-export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
+export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
+	const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
 	return nativeResponseValue;
 }
-	// struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
+	// struct LDKAPIError APIError_invalid_route(struct LDKStr err);
 /* @internal */
-export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
+export function APIError_invalid_route(err: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
+	const nativeResponseValue = wasm.TS_APIError_invalid_route(err);
 	return nativeResponseValue;
 }
-	// struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
+	// struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
 /* @internal */
-export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
-/* @internal */
-export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
-/* @internal */
-export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
-/* @internal */
-export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
-/* @internal */
-export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_send_channel_announcement(struct LDKPublicKey node_id, struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
-/* @internal */
-export function MessageSendEvent_send_channel_announcement(node_id: number, msg: bigint, update_msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_announcement(node_id, msg, update_msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
-/* @internal */
-export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
-/* @internal */
-export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
-/* @internal */
-export function MessageSendEvent_broadcast_node_announcement(msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
-/* @internal */
-export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
-/* @internal */
-export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
-/* @internal */
-export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
-/* @internal */
-export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
-/* @internal */
-export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
-	return nativeResponseValue;
-}
-	// struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
-/* @internal */
-export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
-	return nativeResponseValue;
-}
-	// void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
-/* @internal */
-export function MessageSendEventsProvider_free(this_ptr: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
-	// debug statements here
-}
-	// void OnionMessageProvider_free(struct LDKOnionMessageProvider this_ptr);
-/* @internal */
-export function OnionMessageProvider_free(this_ptr: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_OnionMessageProvider_free(this_ptr);
-	// debug statements here
-}
-	// void EventsProvider_free(struct LDKEventsProvider this_ptr);
-/* @internal */
-export function EventsProvider_free(this_ptr: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
-	// debug statements here
-}
-	// void EventHandler_free(struct LDKEventHandler this_ptr);
-/* @internal */
-export function EventHandler_free(this_ptr: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
-	// debug statements here
-}
-	// void APIError_free(struct LDKAPIError this_ptr);
-/* @internal */
-export function APIError_free(this_ptr: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
-	// debug statements here
-}
-	// uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
-/* @internal */
-export function APIError_clone_ptr(arg: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
-	return nativeResponseValue;
-}
-	// struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
-/* @internal */
-export function APIError_clone(orig: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_APIError_clone(orig);
-	return nativeResponseValue;
-}
-	// struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
-/* @internal */
-export function APIError_apimisuse_error(err: number): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
-	return nativeResponseValue;
-}
-	// struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
-/* @internal */
-export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
-	return nativeResponseValue;
-}
-	// struct LDKAPIError APIError_invalid_route(struct LDKStr err);
-/* @internal */
-export function APIError_invalid_route(err: number): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_APIError_invalid_route(err);
-	return nativeResponseValue;
-}
-	// struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
-/* @internal */
-export function APIError_channel_unavailable(err: number): bigint {
+export function APIError_channel_unavailable(err: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
@@ -18997,6 +18957,87 @@ export function Persister_free(this_ptr: bigint): void {
 	}
 	const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
 	// debug statements here
+}
+	// void UntrustedString_free(struct LDKUntrustedString this_obj);
+/* @internal */
+export function UntrustedString_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_UntrustedString_free(this_obj);
+	// debug statements here
+}
+	// struct LDKStr UntrustedString_get_a(const struct LDKUntrustedString *NONNULL_PTR this_ptr);
+/* @internal */
+export function UntrustedString_get_a(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_UntrustedString_get_a(this_ptr);
+	return nativeResponseValue;
+}
+	// void UntrustedString_set_a(struct LDKUntrustedString *NONNULL_PTR this_ptr, struct LDKStr val);
+/* @internal */
+export function UntrustedString_set_a(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_UntrustedString_set_a(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKUntrustedString UntrustedString_new(struct LDKStr a_arg);
+/* @internal */
+export function UntrustedString_new(a_arg: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_UntrustedString_new(a_arg);
+	return nativeResponseValue;
+}
+	// uint64_t UntrustedString_clone_ptr(LDKUntrustedString *NONNULL_PTR arg);
+/* @internal */
+export function UntrustedString_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_UntrustedString_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKUntrustedString UntrustedString_clone(const struct LDKUntrustedString *NONNULL_PTR orig);
+/* @internal */
+export function UntrustedString_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_UntrustedString_clone(orig);
+	return nativeResponseValue;
+}
+	// bool UntrustedString_eq(const struct LDKUntrustedString *NONNULL_PTR a, const struct LDKUntrustedString *NONNULL_PTR b);
+/* @internal */
+export function UntrustedString_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_UntrustedString_eq(a, b);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z UntrustedString_write(const struct LDKUntrustedString *NONNULL_PTR obj);
+/* @internal */
+export function UntrustedString_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_UntrustedString_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_UntrustedStringDecodeErrorZ UntrustedString_read(struct LDKu8slice ser);
+/* @internal */
+export function UntrustedString_read(ser: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_UntrustedString_read(ser);
+	return nativeResponseValue;
 }
 	// void PrintableString_free(struct LDKPrintableString this_obj);
 /* @internal */
@@ -19051,6 +19092,24 @@ export function Future_free(this_obj: bigint): void {
 	}
 	const nativeResponseValue = wasm.TS_Future_free(this_obj);
 	// debug statements here
+}
+	// uint64_t Future_clone_ptr(LDKFuture *NONNULL_PTR arg);
+/* @internal */
+export function Future_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Future_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKFuture Future_clone(const struct LDKFuture *NONNULL_PTR orig);
+/* @internal */
+export function Future_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Future_clone(orig);
+	return nativeResponseValue;
 }
 	// void Future_register_callback_fn(const struct LDKFuture *NONNULL_PTR this_arg, struct LDKFutureCallback callback);
 /* @internal */
@@ -19430,13 +19489,31 @@ export function ChannelHandshakeConfig_set_their_channel_reserve_proportional_mi
 	const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr, val);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_new(uint32_t minimum_depth_arg, uint16_t our_to_self_delay_arg, uint64_t our_htlc_minimum_msat_arg, uint8_t max_inbound_htlc_value_in_flight_percent_of_channel_arg, bool negotiate_scid_privacy_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg, uint32_t their_channel_reserve_proportional_millionths_arg);
+	// uint16_t ChannelHandshakeConfig_get_our_max_accepted_htlcs(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
 /* @internal */
-export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: bigint, max_inbound_htlc_value_in_flight_percent_of_channel_arg: number, negotiate_scid_privacy_arg: boolean, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean, their_channel_reserve_proportional_millionths_arg: number): bigint {
+export function ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg, max_inbound_htlc_value_in_flight_percent_of_channel_arg, negotiate_scid_privacy_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg, their_channel_reserve_proportional_millionths_arg);
+	const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr);
+	return nativeResponseValue;
+}
+	// void ChannelHandshakeConfig_set_our_max_accepted_htlcs(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
+/* @internal */
+export function ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_new(uint32_t minimum_depth_arg, uint16_t our_to_self_delay_arg, uint64_t our_htlc_minimum_msat_arg, uint8_t max_inbound_htlc_value_in_flight_percent_of_channel_arg, bool negotiate_scid_privacy_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg, uint32_t their_channel_reserve_proportional_millionths_arg, uint16_t our_max_accepted_htlcs_arg);
+/* @internal */
+export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: bigint, max_inbound_htlc_value_in_flight_percent_of_channel_arg: number, negotiate_scid_privacy_arg: boolean, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean, their_channel_reserve_proportional_millionths_arg: number, our_max_accepted_htlcs_arg: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg, max_inbound_htlc_value_in_flight_percent_of_channel_arg, negotiate_scid_privacy_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg, their_channel_reserve_proportional_millionths_arg, our_max_accepted_htlcs_arg);
 	return nativeResponseValue;
 }
 	// uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
@@ -20482,6 +20559,24 @@ export function ChainMonitor_channel_monitor_updated(this_arg: bigint, funding_t
 	}
 	const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
 	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKFuture ChainMonitor_get_update_future(const struct LDKChainMonitor *NONNULL_PTR this_arg);
+/* @internal */
+export function ChainMonitor_get_update_future(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChainMonitor_get_update_future(this_arg);
+	return nativeResponseValue;
+}
+	// void ChainMonitor_rebroadcast_pending_claims(const struct LDKChainMonitor *NONNULL_PTR this_arg);
+/* @internal */
+export function ChainMonitor_rebroadcast_pending_claims(this_arg: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChainMonitor_rebroadcast_pending_claims(this_arg);
+	// debug statements here
 }
 	// struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
 /* @internal */
@@ -20563,6 +20658,15 @@ export function ChannelMonitorUpdate_clone(orig: bigint): bigint {
 	}
 	const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
 	return nativeResponseValue;
+}
+	// bool ChannelMonitorUpdate_eq(const struct LDKChannelMonitorUpdate *NONNULL_PTR a, const struct LDKChannelMonitorUpdate *NONNULL_PTR b);
+/* @internal */
+export function ChannelMonitorUpdate_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_eq(a, b);
+	return nativeResponseValue;
 }
 	// struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
 /* @internal */
@@ -20995,6 +21099,15 @@ export function ChannelMonitor_current_best_block(this_arg: bigint): bigint {
 	}
 	const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
 	return nativeResponseValue;
+}
+	// void ChannelMonitor_rebroadcast_pending_claims(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
+/* @internal */
+export function ChannelMonitor_rebroadcast_pending_claims(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelMonitor_rebroadcast_pending_claims(this_arg, broadcaster, fee_estimator, logger);
+	// debug statements here
 }
 	// MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
 /* @internal */
@@ -21770,13 +21883,13 @@ export function InMemorySigner_clone(orig: bigint): bigint {
 	const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKInMemorySigner InMemorySigner_new(struct LDKSecretKey funding_key, struct LDKSecretKey revocation_base_key, struct LDKSecretKey payment_key, struct LDKSecretKey delayed_payment_base_key, struct LDKSecretKey htlc_base_key, struct LDKThirtyTwoBytes commitment_seed, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
+	// MUST_USE_RES struct LDKInMemorySigner InMemorySigner_new(struct LDKSecretKey funding_key, struct LDKSecretKey revocation_base_key, struct LDKSecretKey payment_key, struct LDKSecretKey delayed_payment_base_key, struct LDKSecretKey htlc_base_key, struct LDKThirtyTwoBytes commitment_seed, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id, struct LDKThirtyTwoBytes rand_bytes_unique_start);
 /* @internal */
-export function InMemorySigner_new(funding_key: number, revocation_base_key: number, payment_key: number, delayed_payment_base_key: number, htlc_base_key: number, commitment_seed: number, channel_value_satoshis: bigint, channel_keys_id: number): bigint {
+export function InMemorySigner_new(funding_key: number, revocation_base_key: number, payment_key: number, delayed_payment_base_key: number, htlc_base_key: number, commitment_seed: number, channel_value_satoshis: bigint, channel_keys_id: number, rand_bytes_unique_start: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_InMemorySigner_new(funding_key, revocation_base_key, payment_key, delayed_payment_base_key, htlc_base_key, commitment_seed, channel_value_satoshis, channel_keys_id);
+	const nativeResponseValue = wasm.TS_InMemorySigner_new(funding_key, revocation_base_key, payment_key, delayed_payment_base_key, htlc_base_key, commitment_seed, channel_value_satoshis, channel_keys_id, rand_bytes_unique_start);
 	return nativeResponseValue;
 }
 	// MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
@@ -21859,6 +21972,15 @@ export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: bigint, spend_
 	}
 	const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
 	return nativeResponseValue;
+}
+	// struct LDKEntropySource InMemorySigner_as_EntropySource(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
+/* @internal */
+export function InMemorySigner_as_EntropySource(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InMemorySigner_as_EntropySource(this_arg);
+	return nativeResponseValue;
 }
 	// struct LDKChannelSigner InMemorySigner_as_ChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
 /* @internal */
@@ -21896,13 +22018,13 @@ export function InMemorySigner_write(obj: bigint): number {
 	const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser);
+	// struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKEntropySource arg);
 /* @internal */
-export function InMemorySigner_read(ser: number): bigint {
+export function InMemorySigner_read(ser: number, arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_InMemorySigner_read(ser);
+	const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
 	return nativeResponseValue;
 }
 	// void KeysManager_free(struct LDKKeysManager this_obj);
@@ -22597,6 +22719,24 @@ export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: number
 	}
 	const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
 	// debug statements here
+}
+	// struct LDKCOption_u32Z ChannelDetails_get_feerate_sat_per_1000_weight(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr);
+	return nativeResponseValue;
+}
+	// void ChannelDetails_set_feerate_sat_per_1000_weight(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
+/* @internal */
+export function ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr, val);
+	// debug statements here
 }
 	// uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
 /* @internal */
@@ -22850,13 +22990,13 @@ export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
 	const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKChannelTypeFeatures channel_type_arg, struct LDKCOption_u64Z short_channel_id_arg, struct LDKCOption_u64Z outbound_scid_alias_arg, struct LDKCOption_u64Z inbound_scid_alias_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, struct LDKU128 user_channel_id_arg, uint64_t balance_msat_arg, uint64_t outbound_capacity_msat_arg, uint64_t next_outbound_htlc_limit_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u32Z confirmations_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_channel_ready_arg, bool is_usable_arg, bool is_public_arg, struct LDKCOption_u64Z inbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z inbound_htlc_maximum_msat_arg, struct LDKChannelConfig config_arg);
+	// MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKChannelTypeFeatures channel_type_arg, struct LDKCOption_u64Z short_channel_id_arg, struct LDKCOption_u64Z outbound_scid_alias_arg, struct LDKCOption_u64Z inbound_scid_alias_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, struct LDKU128 user_channel_id_arg, struct LDKCOption_u32Z feerate_sat_per_1000_weight_arg, uint64_t balance_msat_arg, uint64_t outbound_capacity_msat_arg, uint64_t next_outbound_htlc_limit_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u32Z confirmations_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_channel_ready_arg, bool is_usable_arg, bool is_public_arg, struct LDKCOption_u64Z inbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z inbound_htlc_maximum_msat_arg, struct LDKChannelConfig config_arg);
 /* @internal */
-export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: bigint, funding_txo_arg: bigint, channel_type_arg: bigint, short_channel_id_arg: bigint, outbound_scid_alias_arg: bigint, inbound_scid_alias_arg: bigint, channel_value_satoshis_arg: bigint, unspendable_punishment_reserve_arg: bigint, user_channel_id_arg: number, balance_msat_arg: bigint, outbound_capacity_msat_arg: bigint, next_outbound_htlc_limit_msat_arg: bigint, inbound_capacity_msat_arg: bigint, confirmations_required_arg: bigint, confirmations_arg: bigint, force_close_spend_delay_arg: bigint, is_outbound_arg: boolean, is_channel_ready_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean, inbound_htlc_minimum_msat_arg: bigint, inbound_htlc_maximum_msat_arg: bigint, config_arg: bigint): bigint {
+export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: bigint, funding_txo_arg: bigint, channel_type_arg: bigint, short_channel_id_arg: bigint, outbound_scid_alias_arg: bigint, inbound_scid_alias_arg: bigint, channel_value_satoshis_arg: bigint, unspendable_punishment_reserve_arg: bigint, user_channel_id_arg: number, feerate_sat_per_1000_weight_arg: bigint, balance_msat_arg: bigint, outbound_capacity_msat_arg: bigint, next_outbound_htlc_limit_msat_arg: bigint, inbound_capacity_msat_arg: bigint, confirmations_required_arg: bigint, confirmations_arg: bigint, force_close_spend_delay_arg: bigint, is_outbound_arg: boolean, is_channel_ready_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean, inbound_htlc_minimum_msat_arg: bigint, inbound_htlc_maximum_msat_arg: bigint, config_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelDetails_new(channel_id_arg, counterparty_arg, funding_txo_arg, channel_type_arg, short_channel_id_arg, outbound_scid_alias_arg, inbound_scid_alias_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, balance_msat_arg, outbound_capacity_msat_arg, next_outbound_htlc_limit_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, confirmations_arg, force_close_spend_delay_arg, is_outbound_arg, is_channel_ready_arg, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg, inbound_htlc_maximum_msat_arg, config_arg);
+	const nativeResponseValue = wasm.TS_ChannelDetails_new(channel_id_arg, counterparty_arg, funding_txo_arg, channel_type_arg, short_channel_id_arg, outbound_scid_alias_arg, inbound_scid_alias_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, feerate_sat_per_1000_weight_arg, balance_msat_arg, outbound_capacity_msat_arg, next_outbound_htlc_limit_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, confirmations_arg, force_close_spend_delay_arg, is_outbound_arg, is_channel_ready_arg, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg, inbound_htlc_maximum_msat_arg, config_arg);
 	return nativeResponseValue;
 }
 	// uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
@@ -23083,6 +23223,15 @@ export function ChannelManager_list_usable_channels(this_arg: bigint): number {
 	}
 	const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
 	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels_with_counterparty(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id);
+/* @internal */
+export function ChannelManager_list_channels_with_counterparty(this_arg: bigint, counterparty_node_id: number): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelManager_list_channels_with_counterparty(this_arg, counterparty_node_id);
+	return nativeResponseValue;
 }
 	// MUST_USE_RES struct LDKCVec_RecentPaymentDetailsZ ChannelManager_list_recent_payments(const struct LDKChannelManager *NONNULL_PTR this_arg);
 /* @internal */
@@ -23147,22 +23296,22 @@ export function ChannelManager_force_close_all_channels_without_broadcasting_txn
 	const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret, struct LDKThirtyTwoBytes payment_id);
+	// MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment_with_route(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id);
 /* @internal */
-export function ChannelManager_send_payment(this_arg: bigint, route: bigint, payment_hash: number, payment_secret: number, payment_id: number): bigint {
+export function ChannelManager_send_payment_with_route(this_arg: bigint, route: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret, payment_id);
+	const nativeResponseValue = wasm.TS_ChannelManager_send_payment_with_route(this_arg, route, payment_hash, recipient_onion, payment_id);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCResult_NoneRetryableSendFailureZ ChannelManager_send_payment_with_retry(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
+	// MUST_USE_RES struct LDKCResult_NoneRetryableSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
 /* @internal */
-export function ChannelManager_send_payment_with_retry(this_arg: bigint, payment_hash: number, payment_secret: number, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
+export function ChannelManager_send_payment(this_arg: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelManager_send_payment_with_retry(this_arg, payment_hash, payment_secret, payment_id, route_params, retry_strategy);
+	const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, payment_hash, recipient_onion, payment_id, route_params, retry_strategy);
 	return nativeResponseValue;
 }
 	// void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
@@ -23174,31 +23323,31 @@ export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: num
 	const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKCResult_PaymentHashPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_id);
+	// MUST_USE_RES struct LDKCResult_PaymentHashPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id);
 /* @internal */
-export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: number, payment_id: number): bigint {
+export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: number, recipient_onion: bigint, payment_id: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage, payment_id);
+	const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage, recipient_onion, payment_id);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCResult_PaymentHashRetryableSendFailureZ ChannelManager_send_spontaneous_payment_with_retry(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
+	// MUST_USE_RES struct LDKCResult_PaymentHashRetryableSendFailureZ ChannelManager_send_spontaneous_payment_with_retry(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
 /* @internal */
-export function ChannelManager_send_spontaneous_payment_with_retry(this_arg: bigint, payment_preimage: number, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
+export function ChannelManager_send_spontaneous_payment_with_retry(this_arg: bigint, payment_preimage: number, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment_with_retry(this_arg, payment_preimage, payment_id, route_params, retry_strategy);
+	const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment_with_retry(this_arg, payment_preimage, recipient_onion, payment_id, route_params, retry_strategy);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ hops);
+	// MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPath path);
 /* @internal */
-export function ChannelManager_send_probe(this_arg: bigint, hops: number): bigint {
+export function ChannelManager_send_probe(this_arg: bigint, path: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, hops);
+	const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, path);
 	return nativeResponseValue;
 }
 	// MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKPublicKey counterparty_node_id, struct LDKTransaction funding_transaction);
@@ -23425,15 +23574,6 @@ export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
 	}
 	const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
 	return nativeResponseValue;
-}
-	// void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
-/* @internal */
-export function ChannelManager_await_persistable_update(this_arg: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
-	// debug statements here
 }
 	// MUST_USE_RES struct LDKFuture ChannelManager_get_persistable_update_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
 /* @internal */
@@ -26810,18 +26950,18 @@ export function UnsignedNodeAnnouncement_set_rgb(this_ptr: bigint, val: number):
 	const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
 	// debug statements here
 }
-	// const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
+	// struct LDKNodeAlias UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
 /* @internal */
-export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): number {
+export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
 	const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
 	return nativeResponseValue;
 }
-	// void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+	// void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
 /* @internal */
-export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: number): void {
+export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
@@ -30319,6 +30459,15 @@ export function ChannelTransactionParameters_clone(orig: bigint): bigint {
 	}
 	const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
 	return nativeResponseValue;
+}
+	// bool ChannelTransactionParameters_eq(const struct LDKChannelTransactionParameters *NONNULL_PTR a, const struct LDKChannelTransactionParameters *NONNULL_PTR b);
+/* @internal */
+export function ChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelTransactionParameters_eq(a, b);
+	return nativeResponseValue;
 }
 	// void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
 /* @internal */
@@ -30391,6 +30540,15 @@ export function CounterpartyChannelTransactionParameters_clone(orig: bigint): bi
 	}
 	const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
 	return nativeResponseValue;
+}
+	// bool CounterpartyChannelTransactionParameters_eq(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR a, const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR b);
+/* @internal */
+export function CounterpartyChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_eq(a, b);
+	return nativeResponseValue;
 }
 	// MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
 /* @internal */
@@ -30707,13 +30865,22 @@ export function BuiltCommitmentTransaction_get_sighash_all(this_arg: bigint, fun
 	const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKSignature BuiltCommitmentTransaction_sign(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
+	// MUST_USE_RES struct LDKSignature BuiltCommitmentTransaction_sign_counterparty_commitment(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
+/* @internal */
+export function BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKSignature BuiltCommitmentTransaction_sign_holder_commitment(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis, const struct LDKEntropySource *NONNULL_PTR entropy_source);
 /* @internal */
-export function BuiltCommitmentTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
+export function BuiltCommitmentTransaction_sign_holder_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint, entropy_source: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
+	const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_holder_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis, entropy_source);
 	return nativeResponseValue;
 }
 	// void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
@@ -31004,13 +31171,13 @@ export function TrustedCommitmentTransaction_opt_anchors(this_arg: bigint): bool
 	const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCResult_CVec_SignatureZNoneZ TrustedCommitmentTransaction_get_htlc_sigs(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*htlc_base_key)[32], const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR channel_parameters);
+	// MUST_USE_RES struct LDKCResult_CVec_SignatureZNoneZ TrustedCommitmentTransaction_get_htlc_sigs(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*htlc_base_key)[32], const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR channel_parameters, const struct LDKEntropySource *NONNULL_PTR entropy_source);
 /* @internal */
-export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint): bigint {
+export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint, entropy_source: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
+	const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters, entropy_source);
 	return nativeResponseValue;
 }
 	// uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
@@ -32830,6 +32997,42 @@ export function ChannelTypeFeatures_requires_scid_privacy(this_arg: bigint): boo
 	}
 	const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
 	return nativeResponseValue;
+}
+	// void InvoiceFeatures_set_payment_metadata_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceFeatures_set_payment_metadata_optional(this_arg: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_metadata_optional(this_arg);
+	// debug statements here
+}
+	// void InvoiceFeatures_set_payment_metadata_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceFeatures_set_payment_metadata_required(this_arg: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_metadata_required(this_arg);
+	// debug statements here
+}
+	// MUST_USE_RES bool InvoiceFeatures_supports_payment_metadata(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceFeatures_supports_payment_metadata(this_arg: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_metadata(this_arg);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES bool InvoiceFeatures_requires_payment_metadata(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceFeatures_requires_payment_metadata(this_arg: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_metadata(this_arg);
+	return nativeResponseValue;
 }
 	// void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
 /* @internal */
@@ -33299,3604 +33502,5665 @@ export function PaymentSendFailure_partial_failure(results: number, failed_paths
 	const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
 	return nativeResponseValue;
 }
-	// void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
+	// void RecipientOnionFields_free(struct LDKRecipientOnionFields this_obj);
 /* @internal */
-export function CustomMessageReader_free(this_ptr: bigint): void {
+export function RecipientOnionFields_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_free(this_obj);
 	// debug statements here
 }
-	// uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
+	// struct LDKThirtyTwoBytes RecipientOnionFields_get_payment_secret(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
 /* @internal */
-export function Type_clone_ptr(arg: bigint): bigint {
+export function RecipientOnionFields_get_payment_secret(this_ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_secret(this_ptr);
 	return nativeResponseValue;
 }
-	// struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
+	// void RecipientOnionFields_set_payment_secret(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
 /* @internal */
-export function Type_clone(orig: bigint): bigint {
+export function RecipientOnionFields_set_payment_secret(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Type_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_secret(this_ptr, val);
+	// debug statements here
 }
-	// void Type_free(struct LDKType this_ptr);
+	// struct LDKCOption_CVec_u8ZZ RecipientOnionFields_get_payment_metadata(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
 /* @internal */
-export function Type_free(this_ptr: bigint): void {
+export function RecipientOnionFields_get_payment_metadata(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Type_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_metadata(this_ptr);
+	return nativeResponseValue;
 }
-	// enum LDKUtxoLookupError UtxoLookupError_clone(const enum LDKUtxoLookupError *NONNULL_PTR orig);
+	// void RecipientOnionFields_set_payment_metadata(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
 /* @internal */
-export function UtxoLookupError_clone(orig: bigint): UtxoLookupError {
+export function RecipientOnionFields_set_payment_metadata(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoLookupError_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_metadata(this_ptr, val);
+	// debug statements here
 }
-	// enum LDKUtxoLookupError UtxoLookupError_unknown_chain(void);
+	// MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_new(struct LDKThirtyTwoBytes payment_secret_arg, struct LDKCOption_CVec_u8ZZ payment_metadata_arg);
 /* @internal */
-export function UtxoLookupError_unknown_chain(): UtxoLookupError {
+export function RecipientOnionFields_new(payment_secret_arg: number, payment_metadata_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_chain();
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_new(payment_secret_arg, payment_metadata_arg);
 	return nativeResponseValue;
 }
-	// enum LDKUtxoLookupError UtxoLookupError_unknown_tx(void);
+	// uint64_t RecipientOnionFields_clone_ptr(LDKRecipientOnionFields *NONNULL_PTR arg);
 /* @internal */
-export function UtxoLookupError_unknown_tx(): UtxoLookupError {
+export function RecipientOnionFields_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_tx();
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void UtxoResult_free(struct LDKUtxoResult this_ptr);
+	// struct LDKRecipientOnionFields RecipientOnionFields_clone(const struct LDKRecipientOnionFields *NONNULL_PTR orig);
 /* @internal */
-export function UtxoResult_free(this_ptr: bigint): void {
+export function RecipientOnionFields_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoResult_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_clone(orig);
+	return nativeResponseValue;
 }
-	// uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg);
+	// bool RecipientOnionFields_eq(const struct LDKRecipientOnionFields *NONNULL_PTR a, const struct LDKRecipientOnionFields *NONNULL_PTR b);
 /* @internal */
-export function UtxoResult_clone_ptr(arg: bigint): bigint {
+export function RecipientOnionFields_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoResult_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_eq(a, b);
 	return nativeResponseValue;
 }
-	// struct LDKUtxoResult UtxoResult_clone(const struct LDKUtxoResult *NONNULL_PTR orig);
+	// struct LDKCVec_u8Z RecipientOnionFields_write(const struct LDKRecipientOnionFields *NONNULL_PTR obj);
 /* @internal */
-export function UtxoResult_clone(orig: bigint): bigint {
+export function RecipientOnionFields_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoResult_clone(orig);
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_write(obj);
 	return nativeResponseValue;
 }
-	// struct LDKUtxoResult UtxoResult_sync(struct LDKCResult_TxOutUtxoLookupErrorZ a);
+	// struct LDKCResult_RecipientOnionFieldsDecodeErrorZ RecipientOnionFields_read(struct LDKu8slice ser);
 /* @internal */
-export function UtxoResult_sync(a: bigint): bigint {
+export function RecipientOnionFields_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoResult_sync(a);
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_read(ser);
 	return nativeResponseValue;
 }
-	// struct LDKUtxoResult UtxoResult_async(struct LDKUtxoFuture a);
+	// MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_secret_only(struct LDKThirtyTwoBytes payment_secret);
 /* @internal */
-export function UtxoResult_async(a: bigint): bigint {
+export function RecipientOnionFields_secret_only(payment_secret: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoResult_async(a);
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_secret_only(payment_secret);
 	return nativeResponseValue;
 }
-	// void UtxoLookup_free(struct LDKUtxoLookup this_ptr);
+	// MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_spontaneous_empty(void);
 /* @internal */
-export function UtxoLookup_free(this_ptr: bigint): void {
+export function RecipientOnionFields_spontaneous_empty(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoLookup_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_RecipientOnionFields_spontaneous_empty();
+	return nativeResponseValue;
 }
-	// void UtxoFuture_free(struct LDKUtxoFuture this_obj);
+	// void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
 /* @internal */
-export function UtxoFuture_free(this_obj: bigint): void {
+export function CustomMessageReader_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoFuture_free(this_obj);
+	const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
 	// debug statements here
 }
-	// uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg);
+	// uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
 /* @internal */
-export function UtxoFuture_clone_ptr(arg: bigint): bigint {
+export function Type_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoFuture_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKUtxoFuture UtxoFuture_clone(const struct LDKUtxoFuture *NONNULL_PTR orig);
+	// struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
 /* @internal */
-export function UtxoFuture_clone(orig: bigint): bigint {
+export function Type_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoFuture_clone(orig);
+	const nativeResponseValue = wasm.TS_Type_clone(orig);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKUtxoFuture UtxoFuture_new(void);
+	// void Type_free(struct LDKType this_ptr);
 /* @internal */
-export function UtxoFuture_new(): bigint {
+export function Type_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoFuture_new();
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_Type_free(this_ptr);
+	// debug statements here
 }
-	// void UtxoFuture_resolve_without_forwarding(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, struct LDKCResult_TxOutUtxoLookupErrorZ result);
+	// void UnsignedInvoice_free(struct LDKUnsignedInvoice this_obj);
 /* @internal */
-export function UtxoFuture_resolve_without_forwarding(this_arg: bigint, graph: bigint, result: bigint): void {
+export function UnsignedInvoice_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoFuture_resolve_without_forwarding(this_arg, graph, result);
+	const nativeResponseValue = wasm.TS_UnsignedInvoice_free(this_obj);
 	// debug statements here
 }
-	// void UtxoFuture_resolve(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, const struct LDKP2PGossipSync *NONNULL_PTR gossip, struct LDKCResult_TxOutUtxoLookupErrorZ result);
+	// MUST_USE_RES struct LDKPublicKey UnsignedInvoice_signing_pubkey(const struct LDKUnsignedInvoice *NONNULL_PTR this_arg);
 /* @internal */
-export function UtxoFuture_resolve(this_arg: bigint, graph: bigint, gossip: bigint, result: bigint): void {
+export function UnsignedInvoice_signing_pubkey(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_UtxoFuture_resolve(this_arg, graph, gossip, result);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_UnsignedInvoice_signing_pubkey(this_arg);
+	return nativeResponseValue;
 }
-	// void NodeId_free(struct LDKNodeId this_obj);
+	// void BlindedPayInfo_free(struct LDKBlindedPayInfo this_obj);
 /* @internal */
-export function NodeId_free(this_obj: bigint): void {
+export function BlindedPayInfo_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_free(this_obj);
 	// debug statements here
 }
-	// uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
+	// uint32_t BlindedPayInfo_get_fee_base_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NodeId_clone_ptr(arg: bigint): bigint {
+export function BlindedPayInfo_get_fee_base_msat(this_ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_base_msat(this_ptr);
 	return nativeResponseValue;
 }
-	// struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
+	// void BlindedPayInfo_set_fee_base_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
 /* @internal */
-export function NodeId_clone(orig: bigint): bigint {
+export function BlindedPayInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeId_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_base_msat(this_ptr, val);
+	// debug statements here
 }
-	// MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
+	// uint32_t BlindedPayInfo_get_fee_proportional_millionths(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NodeId_from_pubkey(pubkey: number): bigint {
+export function BlindedPayInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_proportional_millionths(this_ptr);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
+	// void BlindedPayInfo_set_fee_proportional_millionths(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
 /* @internal */
-export function NodeId_as_slice(this_arg: bigint): number {
+export function BlindedPayInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_proportional_millionths(this_ptr, val);
+	// debug statements here
 }
-	// uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
+	// uint16_t BlindedPayInfo_get_cltv_expiry_delta(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NodeId_hash(o: bigint): bigint {
+export function BlindedPayInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeId_hash(o);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_get_cltv_expiry_delta(this_ptr);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
+	// void BlindedPayInfo_set_cltv_expiry_delta(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint16_t val);
 /* @internal */
-export function NodeId_write(obj: bigint): number {
+export function BlindedPayInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeId_write(obj);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_set_cltv_expiry_delta(this_ptr, val);
+	// debug statements here
 }
-	// struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
+	// uint64_t BlindedPayInfo_get_htlc_minimum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NodeId_read(ser: number): bigint {
+export function BlindedPayInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeId_read(ser);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_minimum_msat(this_ptr);
 	return nativeResponseValue;
 }
-	// void NetworkGraph_free(struct LDKNetworkGraph this_obj);
+	// void BlindedPayInfo_set_htlc_minimum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
 /* @internal */
-export function NetworkGraph_free(this_obj: bigint): void {
+export function BlindedPayInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_minimum_msat(this_ptr, val);
 	// debug statements here
 }
-	// void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
+	// uint64_t BlindedPayInfo_get_htlc_maximum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
+export function BlindedPayInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_maximum_msat(this_ptr);
+	return nativeResponseValue;
 }
-	// void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
+	// void BlindedPayInfo_set_htlc_maximum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
 /* @internal */
-export function NetworkUpdate_free(this_ptr: bigint): void {
+export function BlindedPayInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_maximum_msat(this_ptr, val);
 	// debug statements here
 }
-	// uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
+	// struct LDKBlindedHopFeatures BlindedPayInfo_get_features(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
+export function BlindedPayInfo_get_features(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_get_features(this_ptr);
 	return nativeResponseValue;
 }
-	// struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
+	// void BlindedPayInfo_set_features(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, struct LDKBlindedHopFeatures val);
 /* @internal */
-export function NetworkUpdate_clone(orig: bigint): bigint {
+export function BlindedPayInfo_set_features(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_set_features(this_ptr, val);
+	// debug statements here
 }
-	// struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
+	// MUST_USE_RES struct LDKBlindedPayInfo BlindedPayInfo_new(uint32_t fee_base_msat_arg, uint32_t fee_proportional_millionths_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg, struct LDKBlindedHopFeatures features_arg);
 /* @internal */
-export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
+export function BlindedPayInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint, features_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, features_arg);
 	return nativeResponseValue;
 }
-	// struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
+	// uint64_t BlindedPayInfo_clone_ptr(LDKBlindedPayInfo *NONNULL_PTR arg);
 /* @internal */
-export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
+export function BlindedPayInfo_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
+	// struct LDKBlindedPayInfo BlindedPayInfo_clone(const struct LDKBlindedPayInfo *NONNULL_PTR orig);
 /* @internal */
-export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
+export function BlindedPayInfo_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_clone(orig);
 	return nativeResponseValue;
 }
-	// bool NetworkUpdate_eq(const struct LDKNetworkUpdate *NONNULL_PTR a, const struct LDKNetworkUpdate *NONNULL_PTR b);
+	// uint64_t BlindedPayInfo_hash(const struct LDKBlindedPayInfo *NONNULL_PTR o);
 /* @internal */
-export function NetworkUpdate_eq(a: bigint, b: bigint): boolean {
+export function BlindedPayInfo_hash(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkUpdate_eq(a, b);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_hash(o);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
+	// bool BlindedPayInfo_eq(const struct LDKBlindedPayInfo *NONNULL_PTR a, const struct LDKBlindedPayInfo *NONNULL_PTR b);
 /* @internal */
-export function NetworkUpdate_write(obj: bigint): number {
+export function BlindedPayInfo_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_eq(a, b);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
+	// struct LDKCVec_u8Z BlindedPayInfo_write(const struct LDKBlindedPayInfo *NONNULL_PTR obj);
 /* @internal */
-export function NetworkUpdate_read(ser: number): bigint {
+export function BlindedPayInfo_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_write(obj);
 	return nativeResponseValue;
 }
-	// void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
-/* @internal */
-export function P2PGossipSync_free(this_obj: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
-	// debug statements here
-}
-	// MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_UtxoLookupZ utxo_lookup, struct LDKLogger logger);
+	// struct LDKCResult_BlindedPayInfoDecodeErrorZ BlindedPayInfo_read(struct LDKu8slice ser);
 /* @internal */
-export function P2PGossipSync_new(network_graph: bigint, utxo_lookup: bigint, logger: bigint): bigint {
+export function BlindedPayInfo_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, utxo_lookup, logger);
+	const nativeResponseValue = wasm.TS_BlindedPayInfo_read(ser);
 	return nativeResponseValue;
 }
-	// void P2PGossipSync_add_utxo_lookup(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_UtxoLookupZ utxo_lookup);
+	// void UnsignedInvoiceRequest_free(struct LDKUnsignedInvoiceRequest this_obj);
 /* @internal */
-export function P2PGossipSync_add_utxo_lookup(this_arg: bigint, utxo_lookup: bigint): void {
+export function UnsignedInvoiceRequest_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_P2PGossipSync_add_utxo_lookup(this_arg, utxo_lookup);
+	const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_free(this_obj);
 	// debug statements here
 }
-	// void NetworkGraph_handle_network_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNetworkUpdate *NONNULL_PTR network_update);
+	// void InvoiceRequest_free(struct LDKInvoiceRequest this_obj);
 /* @internal */
-export function NetworkGraph_handle_network_update(this_arg: bigint, network_update: bigint): void {
+export function InvoiceRequest_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_handle_network_update(this_arg, network_update);
+	const nativeResponseValue = wasm.TS_InvoiceRequest_free(this_obj);
 	// debug statements here
 }
-	// struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
+	// uint64_t InvoiceRequest_clone_ptr(LDKInvoiceRequest *NONNULL_PTR arg);
 /* @internal */
-export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
+export function InvoiceRequest_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
+	const nativeResponseValue = wasm.TS_InvoiceRequest_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
+	// struct LDKInvoiceRequest InvoiceRequest_clone(const struct LDKInvoiceRequest *NONNULL_PTR orig);
 /* @internal */
-export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
+export function InvoiceRequest_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
+	const nativeResponseValue = wasm.TS_InvoiceRequest_clone(orig);
 	return nativeResponseValue;
 }
-	// void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
+	// MUST_USE_RES struct LDKu8slice InvoiceRequest_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_free(this_obj: bigint): void {
+export function InvoiceRequest_metadata(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_InvoiceRequest_metadata(this_arg);
+	return nativeResponseValue;
 }
-	// uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKThirtyTwoBytes InvoiceRequest_chain(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
+export function InvoiceRequest_chain(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
+	const nativeResponseValue = wasm.TS_InvoiceRequest_chain(this_arg);
 	return nativeResponseValue;
 }
-	// void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
+	// MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_amount_msats(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
+export function InvoiceRequest_amount_msats(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_InvoiceRequest_amount_msats(this_arg);
+	return nativeResponseValue;
 }
-	// bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequest_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
+export function InvoiceRequest_features(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
+	const nativeResponseValue = wasm.TS_InvoiceRequest_features(this_arg);
 	return nativeResponseValue;
 }
-	// void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
+	// MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
+export function InvoiceRequest_quantity(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_InvoiceRequest_quantity(this_arg);
+	return nativeResponseValue;
 }
-	// uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKPublicKey InvoiceRequest_payer_id(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
+export function InvoiceRequest_payer_id(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
+	const nativeResponseValue = wasm.TS_InvoiceRequest_payer_id(this_arg);
 	return nativeResponseValue;
 }
-	// void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
+	// MUST_USE_RES struct LDKPrintableString InvoiceRequest_payer_note(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
+export function InvoiceRequest_payer_note(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_InvoiceRequest_payer_note(this_arg);
+	return nativeResponseValue;
 }
-	// uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+	// struct LDKCVec_u8Z InvoiceRequest_write(const struct LDKInvoiceRequest *NONNULL_PTR obj);
 /* @internal */
-export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
+export function InvoiceRequest_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_InvoiceRequest_write(obj);
 	return nativeResponseValue;
 }
-	// void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
+	// void Offer_free(struct LDKOffer this_obj);
 /* @internal */
-export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
+export function Offer_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
+	const nativeResponseValue = wasm.TS_Offer_free(this_obj);
 	// debug statements here
 }
-	// uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+	// uint64_t Offer_clone_ptr(LDKOffer *NONNULL_PTR arg);
 /* @internal */
-export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
+export function Offer_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_Offer_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
+	// struct LDKOffer Offer_clone(const struct LDKOffer *NONNULL_PTR orig);
 /* @internal */
-export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
+export function Offer_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Offer_clone(orig);
+	return nativeResponseValue;
 }
-	// struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKCVec_ChainHashZ Offer_chains(const struct LDKOffer *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
+export function Offer_chains(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
+	const nativeResponseValue = wasm.TS_Offer_chains(this_arg);
 	return nativeResponseValue;
 }
-	// void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
+	// MUST_USE_RES bool Offer_supports_chain(const struct LDKOffer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes chain);
 /* @internal */
-export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
+export function Offer_supports_chain(this_arg: bigint, chain: number): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Offer_supports_chain(this_arg, chain);
+	return nativeResponseValue;
 }
-	// struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKCOption_CVec_u8ZZ Offer_metadata(const struct LDKOffer *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
+export function Offer_metadata(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
+	const nativeResponseValue = wasm.TS_Offer_metadata(this_arg);
 	return nativeResponseValue;
 }
-	// void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
+	// MUST_USE_RES struct LDKAmount Offer_amount(const struct LDKOffer *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
+export function Offer_amount(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Offer_amount(this_arg);
+	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKChannelUpdateInfo ChannelUpdateInfo_new(uint32_t last_update_arg, bool enabled_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg, struct LDKRoutingFees fees_arg, struct LDKChannelUpdate last_update_message_arg);
+	// MUST_USE_RES struct LDKPrintableString Offer_description(const struct LDKOffer *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_new(last_update_arg: number, enabled_arg: boolean, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint, fees_arg: bigint, last_update_message_arg: bigint): bigint {
+export function Offer_description(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fees_arg, last_update_message_arg);
+	const nativeResponseValue = wasm.TS_Offer_description(this_arg);
 	return nativeResponseValue;
 }
-	// uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
+	// MUST_USE_RES struct LDKOfferFeatures Offer_features(const struct LDKOffer *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
+export function Offer_features(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_Offer_features(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
+	// MUST_USE_RES struct LDKCOption_DurationZ Offer_absolute_expiry(const struct LDKOffer *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_clone(orig: bigint): bigint {
+export function Offer_absolute_expiry(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
+	const nativeResponseValue = wasm.TS_Offer_absolute_expiry(this_arg);
 	return nativeResponseValue;
 }
-	// bool ChannelUpdateInfo_eq(const struct LDKChannelUpdateInfo *NONNULL_PTR a, const struct LDKChannelUpdateInfo *NONNULL_PTR b);
+	// MUST_USE_RES struct LDKPrintableString Offer_issuer(const struct LDKOffer *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_eq(a: bigint, b: bigint): boolean {
+export function Offer_issuer(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
+	const nativeResponseValue = wasm.TS_Offer_issuer(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
+	// MUST_USE_RES struct LDKCVec_BlindedPathZ Offer_paths(const struct LDKOffer *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_write(obj: bigint): number {
+export function Offer_paths(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
+	const nativeResponseValue = wasm.TS_Offer_paths(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
+	// MUST_USE_RES struct LDKQuantity Offer_supported_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelUpdateInfo_read(ser: number): bigint {
+export function Offer_supported_quantity(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
+	const nativeResponseValue = wasm.TS_Offer_supported_quantity(this_arg);
 	return nativeResponseValue;
 }
-	// void ChannelInfo_free(struct LDKChannelInfo this_obj);
+	// MUST_USE_RES bool Offer_is_valid_quantity(const struct LDKOffer *NONNULL_PTR this_arg, uint64_t quantity);
 /* @internal */
-export function ChannelInfo_free(this_obj: bigint): void {
+export function Offer_is_valid_quantity(this_arg: bigint, quantity: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Offer_is_valid_quantity(this_arg, quantity);
+	return nativeResponseValue;
 }
-	// struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+	// MUST_USE_RES bool Offer_expects_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelInfo_get_features(this_ptr: bigint): bigint {
+export function Offer_expects_quantity(this_arg: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
+	const nativeResponseValue = wasm.TS_Offer_expects_quantity(this_arg);
 	return nativeResponseValue;
 }
-	// void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
+	// MUST_USE_RES struct LDKPublicKey Offer_signing_pubkey(const struct LDKOffer *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
+export function Offer_signing_pubkey(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Offer_signing_pubkey(this_arg);
+	return nativeResponseValue;
 }
-	// struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+	// struct LDKCVec_u8Z Offer_write(const struct LDKOffer *NONNULL_PTR obj);
 /* @internal */
-export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
+export function Offer_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
+	const nativeResponseValue = wasm.TS_Offer_write(obj);
 	return nativeResponseValue;
 }
-	// void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
+	// void Amount_free(struct LDKAmount this_obj);
 /* @internal */
-export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
+export function Amount_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
+	const nativeResponseValue = wasm.TS_Amount_free(this_obj);
 	// debug statements here
 }
-	// struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+	// uint64_t Amount_clone_ptr(LDKAmount *NONNULL_PTR arg);
 /* @internal */
-export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
+export function Amount_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
+	const nativeResponseValue = wasm.TS_Amount_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
+	// struct LDKAmount Amount_clone(const struct LDKAmount *NONNULL_PTR orig);
 /* @internal */
-export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
+export function Amount_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Amount_clone(orig);
+	return nativeResponseValue;
 }
-	// struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+	// void Quantity_free(struct LDKQuantity this_obj);
 /* @internal */
-export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
+export function Quantity_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_Quantity_free(this_obj);
+	// debug statements here
 }
-	// void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
+	// uint64_t Quantity_clone_ptr(LDKQuantity *NONNULL_PTR arg);
 /* @internal */
-export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
+export function Quantity_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Quantity_clone_ptr(arg);
+	return nativeResponseValue;
 }
-	// struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+	// struct LDKQuantity Quantity_clone(const struct LDKQuantity *NONNULL_PTR orig);
 /* @internal */
-export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
+export function Quantity_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
+	const nativeResponseValue = wasm.TS_Quantity_clone(orig);
 	return nativeResponseValue;
 }
-	// void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
+	// void Refund_free(struct LDKRefund this_obj);
 /* @internal */
-export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
+export function Refund_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
+	const nativeResponseValue = wasm.TS_Refund_free(this_obj);
 	// debug statements here
 }
-	// struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+	// uint64_t Refund_clone_ptr(LDKRefund *NONNULL_PTR arg);
 /* @internal */
-export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
+export function Refund_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
+	const nativeResponseValue = wasm.TS_Refund_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+	// struct LDKRefund Refund_clone(const struct LDKRefund *NONNULL_PTR orig);
 /* @internal */
-export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
+export function Refund_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Refund_clone(orig);
+	return nativeResponseValue;
 }
-	// struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKPrintableString Refund_description(const struct LDKRefund *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
+export function Refund_description(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
+	const nativeResponseValue = wasm.TS_Refund_description(this_arg);
 	return nativeResponseValue;
 }
-	// void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
+	// MUST_USE_RES struct LDKCOption_DurationZ Refund_absolute_expiry(const struct LDKRefund *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
+export function Refund_absolute_expiry(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Refund_absolute_expiry(this_arg);
+	return nativeResponseValue;
 }
-	// uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
+	// MUST_USE_RES struct LDKPrintableString Refund_issuer(const struct LDKRefund *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelInfo_clone_ptr(arg: bigint): bigint {
+export function Refund_issuer(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_Refund_issuer(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
+	// MUST_USE_RES struct LDKCVec_BlindedPathZ Refund_paths(const struct LDKRefund *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelInfo_clone(orig: bigint): bigint {
+export function Refund_paths(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
+	const nativeResponseValue = wasm.TS_Refund_paths(this_arg);
 	return nativeResponseValue;
 }
-	// bool ChannelInfo_eq(const struct LDKChannelInfo *NONNULL_PTR a, const struct LDKChannelInfo *NONNULL_PTR b);
+	// MUST_USE_RES struct LDKu8slice Refund_metadata(const struct LDKRefund *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelInfo_eq(a: bigint, b: bigint): boolean {
+export function Refund_metadata(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_eq(a, b);
+	const nativeResponseValue = wasm.TS_Refund_metadata(this_arg);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
+	// MUST_USE_RES struct LDKThirtyTwoBytes Refund_chain(const struct LDKRefund *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
+export function Refund_chain(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
+	const nativeResponseValue = wasm.TS_Refund_chain(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
+	// MUST_USE_RES uint64_t Refund_amount_msats(const struct LDKRefund *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelInfo_write(obj: bigint): number {
+export function Refund_amount_msats(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
+	const nativeResponseValue = wasm.TS_Refund_amount_msats(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
+	// MUST_USE_RES struct LDKInvoiceRequestFeatures Refund_features(const struct LDKRefund *NONNULL_PTR this_arg);
 /* @internal */
-export function ChannelInfo_read(ser: number): bigint {
+export function Refund_features(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
+	const nativeResponseValue = wasm.TS_Refund_features(this_arg);
 	return nativeResponseValue;
 }
-	// void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
+	// MUST_USE_RES struct LDKCOption_u64Z Refund_quantity(const struct LDKRefund *NONNULL_PTR this_arg);
 /* @internal */
-export function DirectedChannelInfo_free(this_obj: bigint): void {
+export function Refund_quantity(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Refund_quantity(this_arg);
+	return nativeResponseValue;
 }
-	// uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
+	// MUST_USE_RES struct LDKPublicKey Refund_payer_id(const struct LDKRefund *NONNULL_PTR this_arg);
 /* @internal */
-export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
+export function Refund_payer_id(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_Refund_payer_id(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
+	// MUST_USE_RES struct LDKPrintableString Refund_payer_note(const struct LDKRefund *NONNULL_PTR this_arg);
 /* @internal */
-export function DirectedChannelInfo_clone(orig: bigint): bigint {
+export function Refund_payer_note(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
+	const nativeResponseValue = wasm.TS_Refund_payer_note(this_arg);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
+	// struct LDKCVec_u8Z Refund_write(const struct LDKRefund *NONNULL_PTR obj);
 /* @internal */
-export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
+export function Refund_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
+	const nativeResponseValue = wasm.TS_Refund_write(obj);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
+	// enum LDKUtxoLookupError UtxoLookupError_clone(const enum LDKUtxoLookupError *NONNULL_PTR orig);
 /* @internal */
-export function DirectedChannelInfo_htlc_maximum_msat(this_arg: bigint): bigint {
+export function UtxoLookupError_clone(orig: bigint): UtxoLookupError {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
+	const nativeResponseValue = wasm.TS_UtxoLookupError_clone(orig);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
+	// enum LDKUtxoLookupError UtxoLookupError_unknown_chain(void);
 /* @internal */
-export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
+export function UtxoLookupError_unknown_chain(): UtxoLookupError {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
+	const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_chain();
 	return nativeResponseValue;
 }
-	// void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
+	// enum LDKUtxoLookupError UtxoLookupError_unknown_tx(void);
 /* @internal */
-export function EffectiveCapacity_free(this_ptr: bigint): void {
+export function UtxoLookupError_unknown_tx(): UtxoLookupError {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_tx();
+	return nativeResponseValue;
 }
-	// uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
+	// void UtxoResult_free(struct LDKUtxoResult this_ptr);
 /* @internal */
-export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
+export function UtxoResult_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_UtxoResult_free(this_ptr);
+	// debug statements here
 }
-	// struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
+	// uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg);
 /* @internal */
-export function EffectiveCapacity_clone(orig: bigint): bigint {
+export function UtxoResult_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
+	const nativeResponseValue = wasm.TS_UtxoResult_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
+	// struct LDKUtxoResult UtxoResult_clone(const struct LDKUtxoResult *NONNULL_PTR orig);
 /* @internal */
-export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
+export function UtxoResult_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
+	const nativeResponseValue = wasm.TS_UtxoResult_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
+	// struct LDKUtxoResult UtxoResult_sync(struct LDKCResult_TxOutUtxoLookupErrorZ a);
 /* @internal */
-export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): bigint {
+export function UtxoResult_sync(a: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
+	const nativeResponseValue = wasm.TS_UtxoResult_sync(a);
 	return nativeResponseValue;
 }
-	// struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, uint64_t htlc_maximum_msat);
+	// struct LDKUtxoResult UtxoResult_async(struct LDKUtxoFuture a);
 /* @internal */
-export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
+export function UtxoResult_async(a: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
+	const nativeResponseValue = wasm.TS_UtxoResult_async(a);
 	return nativeResponseValue;
 }
-	// struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
+	// void UtxoLookup_free(struct LDKUtxoLookup this_ptr);
 /* @internal */
-export function EffectiveCapacity_infinite(): bigint {
+export function UtxoLookup_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_UtxoLookup_free(this_ptr);
+	// debug statements here
 }
-	// struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
+	// void UtxoFuture_free(struct LDKUtxoFuture this_obj);
 /* @internal */
-export function EffectiveCapacity_unknown(): bigint {
+export function UtxoFuture_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_UtxoFuture_free(this_obj);
+	// debug statements here
 }
-	// MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
+	// uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg);
 /* @internal */
-export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
+export function UtxoFuture_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
+	const nativeResponseValue = wasm.TS_UtxoFuture_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void RoutingFees_free(struct LDKRoutingFees this_obj);
+	// struct LDKUtxoFuture UtxoFuture_clone(const struct LDKUtxoFuture *NONNULL_PTR orig);
 /* @internal */
-export function RoutingFees_free(this_obj: bigint): void {
+export function UtxoFuture_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_UtxoFuture_clone(orig);
+	return nativeResponseValue;
 }
-	// uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKUtxoFuture UtxoFuture_new(void);
 /* @internal */
-export function RoutingFees_get_base_msat(this_ptr: bigint): number {
+export function UtxoFuture_new(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_UtxoFuture_new();
 	return nativeResponseValue;
 }
-	// void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
+	// void UtxoFuture_resolve_without_forwarding(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, struct LDKCResult_TxOutUtxoLookupErrorZ result);
 /* @internal */
-export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
+export function UtxoFuture_resolve_without_forwarding(this_arg: bigint, graph: bigint, result: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
+	const nativeResponseValue = wasm.TS_UtxoFuture_resolve_without_forwarding(this_arg, graph, result);
 	// debug statements here
 }
-	// uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
+	// void UtxoFuture_resolve(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, const struct LDKP2PGossipSync *NONNULL_PTR gossip, struct LDKCResult_TxOutUtxoLookupErrorZ result);
 /* @internal */
-export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
+export function UtxoFuture_resolve(this_arg: bigint, graph: bigint, gossip: bigint, result: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_UtxoFuture_resolve(this_arg, graph, gossip, result);
+	// debug statements here
 }
-	// void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
+	// void NodeId_free(struct LDKNodeId this_obj);
 /* @internal */
-export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
+export function NodeId_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
+	const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
+	// uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
 /* @internal */
-export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
+export function NodeId_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
+	const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
+	// struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
 /* @internal */
-export function RoutingFees_eq(a: bigint, b: bigint): boolean {
+export function NodeId_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
+	const nativeResponseValue = wasm.TS_NodeId_clone(orig);
 	return nativeResponseValue;
 }
-	// uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
+	// MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
 /* @internal */
-export function RoutingFees_clone_ptr(arg: bigint): bigint {
+export function NodeId_from_pubkey(pubkey: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
 	return nativeResponseValue;
 }
-	// struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
+	// MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
 /* @internal */
-export function RoutingFees_clone(orig: bigint): bigint {
+export function NodeId_as_slice(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
+	const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
 	return nativeResponseValue;
 }
-	// uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
+	// MUST_USE_RES struct LDKCResult_PublicKeyErrorZ NodeId_as_pubkey(const struct LDKNodeId *NONNULL_PTR this_arg);
 /* @internal */
-export function RoutingFees_hash(o: bigint): bigint {
+export function NodeId_as_pubkey(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
+	const nativeResponseValue = wasm.TS_NodeId_as_pubkey(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
+	// uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
 /* @internal */
-export function RoutingFees_write(obj: bigint): number {
+export function NodeId_hash(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
+	const nativeResponseValue = wasm.TS_NodeId_hash(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
+	// struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
 /* @internal */
-export function RoutingFees_read(ser: number): bigint {
+export function NodeId_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
+	const nativeResponseValue = wasm.TS_NodeId_write(obj);
 	return nativeResponseValue;
 }
-	// void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
-/* @internal */
-export function NodeAnnouncementInfo_free(this_obj: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
-	// debug statements here
-}
-	// struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
+	// struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
 /* @internal */
-export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
+export function NodeId_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
+	const nativeResponseValue = wasm.TS_NodeId_read(ser);
 	return nativeResponseValue;
 }
-	// void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
+	// void NetworkGraph_free(struct LDKNetworkGraph this_obj);
 /* @internal */
-export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
+export function NetworkGraph_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
+	const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
 	// debug statements here
 }
-	// uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
+	// void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
 /* @internal */
-export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
+export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
+	// debug statements here
 }
-	// void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
+	// void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
 /* @internal */
-export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
+export function NetworkUpdate_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
+	const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
 	// debug statements here
 }
-	// const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
+	// uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
 /* @internal */
-export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
+export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
+	const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
+	// struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
 /* @internal */
-export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
+export function NetworkUpdate_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
+	return nativeResponseValue;
 }
-	// struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
+	// struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
 /* @internal */
-export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
+export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
+	const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
 	return nativeResponseValue;
 }
-	// void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
+	// struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
 /* @internal */
-export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
+export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
+	return nativeResponseValue;
 }
-	// struct LDKCVec_NetAddressZ NodeAnnouncementInfo_get_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
+	// struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
 /* @internal */
-export function NodeAnnouncementInfo_get_addresses(this_ptr: bigint): number {
+export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_addresses(this_ptr);
+	const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
 	return nativeResponseValue;
 }
-	// void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
+	// bool NetworkUpdate_eq(const struct LDKNetworkUpdate *NONNULL_PTR a, const struct LDKNetworkUpdate *NONNULL_PTR b);
 /* @internal */
-export function NodeAnnouncementInfo_set_addresses(this_ptr: bigint, val: number): void {
+export function NetworkUpdate_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_NetworkUpdate_eq(a, b);
+	return nativeResponseValue;
 }
-	// struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
+	// struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
 /* @internal */
-export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
+export function NetworkUpdate_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
+	const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
 	return nativeResponseValue;
 }
-	// void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
+	// struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
 /* @internal */
-export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
+export function NetworkUpdate_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
+	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_new(struct LDKNodeFeatures features_arg, uint32_t last_update_arg, struct LDKThreeBytes rgb_arg, struct LDKNodeAlias alias_arg, struct LDKCVec_NetAddressZ addresses_arg, struct LDKNodeAnnouncement announcement_message_arg);
+	// void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
 /* @internal */
-export function NodeAnnouncementInfo_new(features_arg: bigint, last_update_arg: number, rgb_arg: number, alias_arg: bigint, addresses_arg: number, announcement_message_arg: bigint): bigint {
+export function P2PGossipSync_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
+	// debug statements here
 }
-	// uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
+	// MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_UtxoLookupZ utxo_lookup, struct LDKLogger logger);
 /* @internal */
-export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
+export function P2PGossipSync_new(network_graph: bigint, utxo_lookup: bigint, logger: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, utxo_lookup, logger);
 	return nativeResponseValue;
 }
-	// struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
+	// void P2PGossipSync_add_utxo_lookup(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_UtxoLookupZ utxo_lookup);
 /* @internal */
-export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
+export function P2PGossipSync_add_utxo_lookup(this_arg: bigint, utxo_lookup: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_P2PGossipSync_add_utxo_lookup(this_arg, utxo_lookup);
+	// debug statements here
 }
-	// bool NodeAnnouncementInfo_eq(const struct LDKNodeAnnouncementInfo *NONNULL_PTR a, const struct LDKNodeAnnouncementInfo *NONNULL_PTR b);
+	// void NetworkGraph_handle_network_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNetworkUpdate *NONNULL_PTR network_update);
 /* @internal */
-export function NodeAnnouncementInfo_eq(a: bigint, b: bigint): boolean {
+export function NetworkGraph_handle_network_update(this_arg: bigint, network_update: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_eq(a, b);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_NetworkGraph_handle_network_update(this_arg, network_update);
+	// debug statements here
 }
-	// struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
+	// struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
 /* @internal */
-export function NodeAnnouncementInfo_write(obj: bigint): number {
+export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
+	const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
+	// struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
 /* @internal */
-export function NodeAnnouncementInfo_read(ser: number): bigint {
+export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
+	const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
 	return nativeResponseValue;
 }
-	// void NodeAlias_free(struct LDKNodeAlias this_obj);
+	// void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
 /* @internal */
-export function NodeAlias_free(this_obj: bigint): void {
+export function ChannelUpdateInfo_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
 	// debug statements here
 }
-	// const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
+	// uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NodeAlias_get_a(this_ptr: bigint): number {
+export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
 	return nativeResponseValue;
 }
-	// void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+	// void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
 /* @internal */
-export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
+export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
+	// bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NodeAlias_new(a_arg: number): bigint {
+export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
 	return nativeResponseValue;
 }
-	// uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
+	// void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
 /* @internal */
-export function NodeAlias_clone_ptr(arg: bigint): bigint {
+export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
+	// debug statements here
 }
-	// struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
+	// uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NodeAlias_clone(orig: bigint): bigint {
+export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
 	return nativeResponseValue;
 }
-	// bool NodeAlias_eq(const struct LDKNodeAlias *NONNULL_PTR a, const struct LDKNodeAlias *NONNULL_PTR b);
+	// void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
 /* @internal */
-export function NodeAlias_eq(a: bigint, b: bigint): boolean {
+export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
+	// debug statements here
 }
-	// struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
+	// uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NodeAlias_write(obj: bigint): number {
+export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
+	// void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
 /* @internal */
-export function NodeAlias_read(ser: number): bigint {
+export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
 	return nativeResponseValue;
 }
-	// void NodeInfo_free(struct LDKNodeInfo this_obj);
+	// void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
 /* @internal */
-export function NodeInfo_free(this_obj: bigint): void {
+export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
 	// debug statements here
 }
-	// struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
+	// struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NodeInfo_get_channels(this_ptr: bigint): number {
+export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
 	return nativeResponseValue;
 }
-	// void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
+	// void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
 /* @internal */
-export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
+export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
 	// debug statements here
 }
-	// struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
+	// struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
+export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
 	return nativeResponseValue;
 }
-	// void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
+	// void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
 /* @internal */
-export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
+export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
+	// MUST_USE_RES struct LDKChannelUpdateInfo ChannelUpdateInfo_new(uint32_t last_update_arg, bool enabled_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg, struct LDKRoutingFees fees_arg, struct LDKChannelUpdate last_update_message_arg);
 /* @internal */
-export function NodeInfo_new(channels_arg: number, announcement_info_arg: bigint): bigint {
+export function ChannelUpdateInfo_new(last_update_arg: number, enabled_arg: boolean, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint, fees_arg: bigint, last_update_message_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, announcement_info_arg);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fees_arg, last_update_message_arg);
 	return nativeResponseValue;
 }
-	// uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
+	// uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
 /* @internal */
-export function NodeInfo_clone_ptr(arg: bigint): bigint {
+export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
+	// struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
 /* @internal */
-export function NodeInfo_clone(orig: bigint): bigint {
+export function ChannelUpdateInfo_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
 	return nativeResponseValue;
 }
-	// bool NodeInfo_eq(const struct LDKNodeInfo *NONNULL_PTR a, const struct LDKNodeInfo *NONNULL_PTR b);
+	// bool ChannelUpdateInfo_eq(const struct LDKChannelUpdateInfo *NONNULL_PTR a, const struct LDKChannelUpdateInfo *NONNULL_PTR b);
 /* @internal */
-export function NodeInfo_eq(a: bigint, b: bigint): boolean {
+export function ChannelUpdateInfo_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeInfo_eq(a, b);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
+	// struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
 /* @internal */
-export function NodeInfo_write(obj: bigint): number {
+export function ChannelUpdateInfo_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
+	// struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
 /* @internal */
-export function NodeInfo_read(ser: number): bigint {
+export function ChannelUpdateInfo_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
+	const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
+	// void ChannelInfo_free(struct LDKChannelInfo this_obj);
 /* @internal */
-export function NetworkGraph_write(obj: bigint): number {
+export function ChannelInfo_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
+	// debug statements here
 }
-	// struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
+	// struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NetworkGraph_read(ser: number, arg: bigint): bigint {
+export function ChannelInfo_get_features(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
+	const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(enum LDKNetwork network, struct LDKLogger logger);
+	// void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
 /* @internal */
-export function NetworkGraph_new(network: Network, logger: bigint): bigint {
+export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_new(network, logger);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
+	// debug statements here
 }
-	// MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
+	// struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NetworkGraph_read_only(this_arg: bigint): bigint {
+export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
+	const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
+	// void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
 /* @internal */
-export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
+export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
+	const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
 	return nativeResponseValue;
 }
-	// void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
+	// void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
 /* @internal */
-export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
+export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
+	const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
+	// struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
+export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
+	const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_unsigned_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR msg);
+	// void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
 /* @internal */
-export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
+export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
+	// debug statements here
 }
-	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg, struct LDKCOption_UtxoLookupZ utxo_lookup);
+	// struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
+export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, utxo_lookup);
+	const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_unsigned_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg, struct LDKCOption_UtxoLookupZ utxo_lookup);
+	// void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
 /* @internal */
-export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
+export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, utxo_lookup);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
+	// debug statements here
 }
-	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_add_channel_from_partial_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, uint64_t timestamp, struct LDKChannelFeatures features, struct LDKPublicKey node_id_1, struct LDKPublicKey node_id_2);
+	// struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NetworkGraph_add_channel_from_partial_announcement(this_arg: bigint, short_channel_id: bigint, timestamp: bigint, features: bigint, node_id_1: number, node_id_2: number): bigint {
+export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
+	const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
 	return nativeResponseValue;
 }
-	// void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
+	// void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
 /* @internal */
-export function NetworkGraph_channel_failed(this_arg: bigint, short_channel_id: bigint, is_permanent: boolean): void {
+export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
+	const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
 	// debug statements here
 }
-	// void NetworkGraph_node_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
+	// struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function NetworkGraph_node_failed_permanent(this_arg: bigint, node_id: number): void {
+export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_node_failed_permanent(this_arg, node_id);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
+	return nativeResponseValue;
 }
-	// void NetworkGraph_remove_stale_channels_and_tracking_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
+	// void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
 /* @internal */
-export function NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg: bigint, current_time_unix: bigint): void {
+export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg, current_time_unix);
+	const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
+	// uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
 /* @internal */
-export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
+export function ChannelInfo_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
+	const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
+	// struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
 /* @internal */
-export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
+export function ChannelInfo_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
+	const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
+	// bool ChannelInfo_eq(const struct LDKChannelInfo *NONNULL_PTR a, const struct LDKChannelInfo *NONNULL_PTR b);
 /* @internal */
-export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
+export function ChannelInfo_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
+	const nativeResponseValue = wasm.TS_ChannelInfo_eq(a, b);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
+	// MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
 /* @internal */
-export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
+export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
+	const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
+	// struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
 /* @internal */
-export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
+export function ChannelInfo_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
+	const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
+	// struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
 /* @internal */
-export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
+export function ChannelInfo_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
+	const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
+	// void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
 /* @internal */
-export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
+export function DirectedChannelInfo_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
+	// debug statements here
 }
-	// void DefaultRouter_free(struct LDKDefaultRouter this_obj);
+	// uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
 /* @internal */
-export function DefaultRouter_free(this_obj: bigint): void {
+export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
+	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes, struct LDKLockableScore scorer);
+	// struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
 /* @internal */
-export function DefaultRouter_new(network_graph: bigint, logger: bigint, random_seed_bytes: number, scorer: bigint): bigint {
+export function DirectedChannelInfo_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes, scorer);
+	const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
+	// MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
 /* @internal */
-export function DefaultRouter_as_Router(this_arg: bigint): bigint {
+export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
+	const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
 	return nativeResponseValue;
 }
-	// void Router_free(struct LDKRouter this_ptr);
+	// MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
 /* @internal */
-export function Router_free(this_ptr: bigint): void {
+export function DirectedChannelInfo_htlc_maximum_msat(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Router_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
+	return nativeResponseValue;
 }
-	// void ScorerAccountingForInFlightHtlcs_free(struct LDKScorerAccountingForInFlightHtlcs this_obj);
+	// MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
 /* @internal */
-export function ScorerAccountingForInFlightHtlcs_free(this_obj: bigint): void {
+export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_free(this_obj);
+	const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
+	return nativeResponseValue;
+}
+	// void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
+/* @internal */
+export function EffectiveCapacity_free(this_ptr: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKScorerAccountingForInFlightHtlcs ScorerAccountingForInFlightHtlcs_new(struct LDKScore scorer, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs);
+	// uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
 /* @internal */
-export function ScorerAccountingForInFlightHtlcs_new(scorer: bigint, inflight_htlcs: bigint): bigint {
+export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_new(scorer, inflight_htlcs);
+	const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z ScorerAccountingForInFlightHtlcs_write(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR obj);
+	// struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
 /* @internal */
-export function ScorerAccountingForInFlightHtlcs_write(obj: bigint): number {
+export function EffectiveCapacity_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_write(obj);
+	const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKScore ScorerAccountingForInFlightHtlcs_as_Score(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR this_arg);
+	// struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
 /* @internal */
-export function ScorerAccountingForInFlightHtlcs_as_Score(this_arg: bigint): bigint {
+export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_as_Score(this_arg);
+	const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
 	return nativeResponseValue;
 }
-	// void InFlightHtlcs_free(struct LDKInFlightHtlcs this_obj);
+	// struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
 /* @internal */
-export function InFlightHtlcs_free(this_obj: bigint): void {
+export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_InFlightHtlcs_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
+	return nativeResponseValue;
 }
-	// uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg);
+	// struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, uint64_t htlc_maximum_msat);
 /* @internal */
-export function InFlightHtlcs_clone_ptr(arg: bigint): bigint {
+export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_InFlightHtlcs_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
 	return nativeResponseValue;
 }
-	// struct LDKInFlightHtlcs InFlightHtlcs_clone(const struct LDKInFlightHtlcs *NONNULL_PTR orig);
+	// struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
 /* @internal */
-export function InFlightHtlcs_clone(orig: bigint): bigint {
+export function EffectiveCapacity_infinite(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_InFlightHtlcs_clone(orig);
+	const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKInFlightHtlcs InFlightHtlcs_new(void);
+	// struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
 /* @internal */
-export function InFlightHtlcs_new(): bigint {
+export function EffectiveCapacity_unknown(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_InFlightHtlcs_new();
+	const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCOption_u64Z InFlightHtlcs_used_liquidity_msat(const struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, uint64_t channel_scid);
+	// MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
 /* @internal */
-export function InFlightHtlcs_used_liquidity_msat(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint): bigint {
+export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_InFlightHtlcs_used_liquidity_msat(this_arg, source, target, channel_scid);
+	const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z InFlightHtlcs_write(const struct LDKInFlightHtlcs *NONNULL_PTR obj);
+	// void RoutingFees_free(struct LDKRoutingFees this_obj);
 /* @internal */
-export function InFlightHtlcs_write(obj: bigint): number {
+export function RoutingFees_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_InFlightHtlcs_write(obj);
+	const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
+	// debug statements here
+}
+	// uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
+/* @internal */
+export function RoutingFees_get_base_msat(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_InFlightHtlcsDecodeErrorZ InFlightHtlcs_read(struct LDKu8slice ser);
+	// void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
 /* @internal */
-export function InFlightHtlcs_read(ser: number): bigint {
+export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_InFlightHtlcs_read(ser);
+	const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
+/* @internal */
+export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
 	return nativeResponseValue;
 }
-	// void RouteHop_free(struct LDKRouteHop this_obj);
+	// void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
 /* @internal */
-export function RouteHop_free(this_obj: bigint): void {
+export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
+	const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
 	// debug statements here
 }
-	// struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
 /* @internal */
-export function RouteHop_get_pubkey(this_ptr: bigint): number {
+export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
+	const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
 	return nativeResponseValue;
 }
-	// void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+	// bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
 /* @internal */
-export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
+export function RoutingFees_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
+	const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
+	return nativeResponseValue;
+}
+	// uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
+/* @internal */
+export function RoutingFees_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
+/* @internal */
+export function RoutingFees_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
+	return nativeResponseValue;
+}
+	// uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
+/* @internal */
+export function RoutingFees_hash(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
+/* @internal */
+export function RoutingFees_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
+/* @internal */
+export function RoutingFees_read(ser: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
+	return nativeResponseValue;
+}
+	// void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
+/* @internal */
+export function NodeAnnouncementInfo_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
 	// debug statements here
 }
-	// struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+	// struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function RouteHop_get_node_features(this_ptr: bigint): bigint {
+export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
 	return nativeResponseValue;
 }
-	// void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
+	// void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
 /* @internal */
-export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
+export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
 	// debug statements here
 }
-	// uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+	// uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
+export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
 	return nativeResponseValue;
 }
-	// void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
+	// void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
 /* @internal */
-export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
+export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
 	// debug statements here
 }
-	// struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+	// const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
 /* @internal */
-export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
+export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
 	return nativeResponseValue;
 }
-	// void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
+	// void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
 /* @internal */
-export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
+export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
 	// debug statements here
 }
-	// uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+	// struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
+export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
 	return nativeResponseValue;
 }
-	// void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
+	// void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
 /* @internal */
-export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
+export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
 	// debug statements here
 }
-	// uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+	// struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
 /* @internal */
-export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
+export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
 	return nativeResponseValue;
 }
-	// void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
+	// void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
 /* @internal */
-export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
+export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKRouteHop RouteHop_new(struct LDKPublicKey pubkey_arg, struct LDKNodeFeatures node_features_arg, uint64_t short_channel_id_arg, struct LDKChannelFeatures channel_features_arg, uint64_t fee_msat_arg, uint32_t cltv_expiry_delta_arg);
+	// MUST_USE_RES struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_new(struct LDKNodeFeatures features_arg, uint32_t last_update_arg, struct LDKThreeBytes rgb_arg, struct LDKNodeAlias alias_arg, struct LDKNodeAnnouncement announcement_message_arg);
 /* @internal */
-export function RouteHop_new(pubkey_arg: number, node_features_arg: bigint, short_channel_id_arg: bigint, channel_features_arg: bigint, fee_msat_arg: bigint, cltv_expiry_delta_arg: number): bigint {
+export function NodeAnnouncementInfo_new(features_arg: bigint, last_update_arg: number, rgb_arg: number, alias_arg: bigint, announcement_message_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_new(pubkey_arg, node_features_arg, short_channel_id_arg, channel_features_arg, fee_msat_arg, cltv_expiry_delta_arg);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, announcement_message_arg);
 	return nativeResponseValue;
 }
-	// uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
+	// uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
 /* @internal */
-export function RouteHop_clone_ptr(arg: bigint): bigint {
+export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
+	// struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
 /* @internal */
-export function RouteHop_clone(orig: bigint): bigint {
+export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
 	return nativeResponseValue;
 }
-	// uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
+	// bool NodeAnnouncementInfo_eq(const struct LDKNodeAnnouncementInfo *NONNULL_PTR a, const struct LDKNodeAnnouncementInfo *NONNULL_PTR b);
 /* @internal */
-export function RouteHop_hash(o: bigint): bigint {
+export function NodeAnnouncementInfo_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_hash(o);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_eq(a, b);
 	return nativeResponseValue;
 }
-	// bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
+	// MUST_USE_RES struct LDKCVec_NetAddressZ NodeAnnouncementInfo_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
 /* @internal */
-export function RouteHop_eq(a: bigint, b: bigint): boolean {
+export function NodeAnnouncementInfo_addresses(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_addresses(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
+	// struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
 /* @internal */
-export function RouteHop_write(obj: bigint): number {
+export function NodeAnnouncementInfo_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_write(obj);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
+	// struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
 /* @internal */
-export function RouteHop_read(ser: number): bigint {
+export function NodeAnnouncementInfo_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHop_read(ser);
+	const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
 	return nativeResponseValue;
 }
-	// void Route_free(struct LDKRoute this_obj);
+	// void NodeAlias_free(struct LDKNodeAlias this_obj);
 /* @internal */
-export function Route_free(this_obj: bigint): void {
+export function NodeAlias_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_free(this_obj);
+	const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
 	// debug statements here
 }
-	// struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
+	// const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
 /* @internal */
-export function Route_get_paths(this_ptr: bigint): number {
+export function NodeAlias_get_a(this_ptr: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
+	const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
 	return nativeResponseValue;
 }
-	// void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
+	// void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
 /* @internal */
-export function Route_set_paths(this_ptr: bigint, val: number): void {
+export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
+	const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
 	// debug statements here
 }
-	// struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
 /* @internal */
-export function Route_get_payment_params(this_ptr: bigint): bigint {
+export function NodeAlias_new(a_arg: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
+	const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
 	return nativeResponseValue;
 }
-	// void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
+	// uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
 /* @internal */
-export function Route_set_payment_params(this_ptr: bigint, val: bigint): void {
+export function NodeAlias_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
+	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
+	// struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
 /* @internal */
-export function Route_new(paths_arg: number, payment_params_arg: bigint): bigint {
+export function NodeAlias_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
+	const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
 	return nativeResponseValue;
 }
-	// uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
+	// bool NodeAlias_eq(const struct LDKNodeAlias *NONNULL_PTR a, const struct LDKNodeAlias *NONNULL_PTR b);
 /* @internal */
-export function Route_clone_ptr(arg: bigint): bigint {
+export function NodeAlias_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
 	return nativeResponseValue;
 }
-	// struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
+	// struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
 /* @internal */
-export function Route_clone(orig: bigint): bigint {
+export function NodeAlias_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_clone(orig);
+	const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
 	return nativeResponseValue;
 }
-	// uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
+	// struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
 /* @internal */
-export function Route_hash(o: bigint): bigint {
+export function NodeAlias_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_hash(o);
+	const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
 	return nativeResponseValue;
 }
-	// bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
+	// void NodeInfo_free(struct LDKNodeInfo this_obj);
 /* @internal */
-export function Route_eq(a: bigint, b: bigint): boolean {
+export function NodeInfo_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_eq(a, b);
+	const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
+	// debug statements here
+}
+	// struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function NodeInfo_get_channels(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
+	// void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
 /* @internal */
-export function Route_get_total_fees(this_arg: bigint): bigint {
+export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
+	const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
+	// void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
 /* @internal */
-export function Route_get_total_amount(this_arg: bigint): bigint {
+export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
+	const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
+/* @internal */
+export function NodeInfo_new(channels_arg: number, announcement_info_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, announcement_info_arg);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
+	// uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
 /* @internal */
-export function Route_write(obj: bigint): number {
+export function NodeInfo_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_write(obj);
+	const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
+	// struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
 /* @internal */
-export function Route_read(ser: number): bigint {
+export function NodeInfo_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Route_read(ser);
+	const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
 	return nativeResponseValue;
 }
-	// void RouteParameters_free(struct LDKRouteParameters this_obj);
+	// bool NodeInfo_eq(const struct LDKNodeInfo *NONNULL_PTR a, const struct LDKNodeInfo *NONNULL_PTR b);
 /* @internal */
-export function RouteParameters_free(this_obj: bigint): void {
+export function NodeInfo_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_NodeInfo_eq(a, b);
+	return nativeResponseValue;
 }
-	// struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
+	// struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
 /* @internal */
-export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
+export function NodeInfo_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
+	const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
 	return nativeResponseValue;
 }
-	// void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
+	// struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
 /* @internal */
-export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
+export function NodeInfo_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
+	return nativeResponseValue;
 }
-	// uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
+	// struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
 /* @internal */
-export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
+export function NetworkGraph_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
 	return nativeResponseValue;
 }
-	// void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
+	// struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
 /* @internal */
-export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
+export function NetworkGraph_read(ser: number, arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
+	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKRouteParameters RouteParameters_new(struct LDKPaymentParameters payment_params_arg, uint64_t final_value_msat_arg);
+	// MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(enum LDKNetwork network, struct LDKLogger logger);
 /* @internal */
-export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint): bigint {
+export function NetworkGraph_new(network: Network, logger: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg);
+	const nativeResponseValue = wasm.TS_NetworkGraph_new(network, logger);
 	return nativeResponseValue;
 }
-	// uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
+	// MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
 /* @internal */
-export function RouteParameters_clone_ptr(arg: bigint): bigint {
+export function NetworkGraph_read_only(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
 	return nativeResponseValue;
 }
-	// struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
+	// MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
 /* @internal */
-export function RouteParameters_clone(orig: bigint): bigint {
+export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
+	const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
 	return nativeResponseValue;
 }
-	// bool RouteParameters_eq(const struct LDKRouteParameters *NONNULL_PTR a, const struct LDKRouteParameters *NONNULL_PTR b);
+	// void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
 /* @internal */
-export function RouteParameters_eq(a: bigint, b: bigint): boolean {
+export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteParameters_eq(a, b);
+	const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
+/* @internal */
+export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
+	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_unsigned_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR msg);
 /* @internal */
-export function RouteParameters_write(obj: bigint): number {
+export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
+	const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
+	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg, struct LDKCOption_UtxoLookupZ utxo_lookup);
 /* @internal */
-export function RouteParameters_read(ser: number): bigint {
+export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
+	const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, utxo_lookup);
 	return nativeResponseValue;
 }
-	// void PaymentParameters_free(struct LDKPaymentParameters this_obj);
+	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_unsigned_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg, struct LDKCOption_UtxoLookupZ utxo_lookup);
 /* @internal */
-export function PaymentParameters_free(this_obj: bigint): void {
+export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, utxo_lookup);
+	return nativeResponseValue;
 }
-	// struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_add_channel_from_partial_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, uint64_t timestamp, struct LDKChannelFeatures features, struct LDKPublicKey node_id_1, struct LDKPublicKey node_id_2);
 /* @internal */
-export function PaymentParameters_get_payee_pubkey(this_ptr: bigint): number {
+export function NetworkGraph_add_channel_from_partial_announcement(this_arg: bigint, short_channel_id: bigint, timestamp: bigint, features: bigint, node_id_1: number, node_id_2: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
+	const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
 	return nativeResponseValue;
 }
-	// void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+	// void NetworkGraph_channel_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
 /* @internal */
-export function PaymentParameters_set_payee_pubkey(this_ptr: bigint, val: number): void {
+export function NetworkGraph_channel_failed_permanent(this_arg: bigint, short_channel_id: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
+	const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed_permanent(this_arg, short_channel_id);
 	// debug statements here
 }
-	// struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+	// void NetworkGraph_node_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
 /* @internal */
-export function PaymentParameters_get_features(this_ptr: bigint): bigint {
+export function NetworkGraph_node_failed_permanent(this_arg: bigint, node_id: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_NetworkGraph_node_failed_permanent(this_arg, node_id);
+	// debug statements here
 }
-	// void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
+	// void NetworkGraph_remove_stale_channels_and_tracking_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
 /* @internal */
-export function PaymentParameters_set_features(this_ptr: bigint, val: bigint): void {
+export function NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg: bigint, current_time_unix: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
+	const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg, current_time_unix);
 	// debug statements here
 }
-	// struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
 /* @internal */
-export function PaymentParameters_get_route_hints(this_ptr: bigint): number {
+export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
+	const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
 	return nativeResponseValue;
 }
-	// void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
+	// MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
 /* @internal */
-export function PaymentParameters_set_route_hints(this_ptr: bigint, val: number): void {
+export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
+	return nativeResponseValue;
 }
-	// struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
 /* @internal */
-export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
+export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
+	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
 	return nativeResponseValue;
 }
-	// void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+	// MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
 /* @internal */
-export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
+export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
+	return nativeResponseValue;
 }
-	// uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
+/* @internal */
+export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
+/* @internal */
+export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
+/* @internal */
+export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
+	return nativeResponseValue;
+}
+	// void DefaultRouter_free(struct LDKDefaultRouter this_obj);
+/* @internal */
+export function DefaultRouter_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes, struct LDKLockableScore scorer);
+/* @internal */
+export function DefaultRouter_new(network_graph: bigint, logger: bigint, random_seed_bytes: number, scorer: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes, scorer);
+	return nativeResponseValue;
+}
+	// struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
+/* @internal */
+export function DefaultRouter_as_Router(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
+	return nativeResponseValue;
+}
+	// void Router_free(struct LDKRouter this_ptr);
+/* @internal */
+export function Router_free(this_ptr: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Router_free(this_ptr);
+	// debug statements here
+}
+	// void ScorerAccountingForInFlightHtlcs_free(struct LDKScorerAccountingForInFlightHtlcs this_obj);
+/* @internal */
+export function ScorerAccountingForInFlightHtlcs_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_free(this_obj);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKScorerAccountingForInFlightHtlcs ScorerAccountingForInFlightHtlcs_new(struct LDKScore scorer, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs);
+/* @internal */
+export function ScorerAccountingForInFlightHtlcs_new(scorer: bigint, inflight_htlcs: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_new(scorer, inflight_htlcs);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z ScorerAccountingForInFlightHtlcs_write(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR obj);
+/* @internal */
+export function ScorerAccountingForInFlightHtlcs_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKScore ScorerAccountingForInFlightHtlcs_as_Score(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR this_arg);
+/* @internal */
+export function ScorerAccountingForInFlightHtlcs_as_Score(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_as_Score(this_arg);
+	return nativeResponseValue;
+}
+	// void InFlightHtlcs_free(struct LDKInFlightHtlcs this_obj);
+/* @internal */
+export function InFlightHtlcs_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InFlightHtlcs_free(this_obj);
+	// debug statements here
+}
+	// uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg);
+/* @internal */
+export function InFlightHtlcs_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InFlightHtlcs_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKInFlightHtlcs InFlightHtlcs_clone(const struct LDKInFlightHtlcs *NONNULL_PTR orig);
+/* @internal */
+export function InFlightHtlcs_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InFlightHtlcs_clone(orig);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKInFlightHtlcs InFlightHtlcs_new(void);
+/* @internal */
+export function InFlightHtlcs_new(): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InFlightHtlcs_new();
+	return nativeResponseValue;
+}
+	// void InFlightHtlcs_process_path(struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, struct LDKPublicKey payer_node_id);
+/* @internal */
+export function InFlightHtlcs_process_path(this_arg: bigint, path: bigint, payer_node_id: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InFlightHtlcs_process_path(this_arg, path, payer_node_id);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKCOption_u64Z InFlightHtlcs_used_liquidity_msat(const struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, uint64_t channel_scid);
+/* @internal */
+export function InFlightHtlcs_used_liquidity_msat(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InFlightHtlcs_used_liquidity_msat(this_arg, source, target, channel_scid);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z InFlightHtlcs_write(const struct LDKInFlightHtlcs *NONNULL_PTR obj);
+/* @internal */
+export function InFlightHtlcs_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InFlightHtlcs_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_InFlightHtlcsDecodeErrorZ InFlightHtlcs_read(struct LDKu8slice ser);
+/* @internal */
+export function InFlightHtlcs_read(ser: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_InFlightHtlcs_read(ser);
+	return nativeResponseValue;
+}
+	// void RouteHop_free(struct LDKRouteHop this_obj);
+/* @internal */
+export function RouteHop_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
+	// debug statements here
+}
+	// struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHop_get_pubkey(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+/* @internal */
+export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHop_get_node_features(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
+/* @internal */
+export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
+/* @internal */
+export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
+/* @internal */
+export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKRouteHop RouteHop_new(struct LDKPublicKey pubkey_arg, struct LDKNodeFeatures node_features_arg, uint64_t short_channel_id_arg, struct LDKChannelFeatures channel_features_arg, uint64_t fee_msat_arg, uint32_t cltv_expiry_delta_arg);
+/* @internal */
+export function RouteHop_new(pubkey_arg: number, node_features_arg: bigint, short_channel_id_arg: bigint, channel_features_arg: bigint, fee_msat_arg: bigint, cltv_expiry_delta_arg: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_new(pubkey_arg, node_features_arg, short_channel_id_arg, channel_features_arg, fee_msat_arg, cltv_expiry_delta_arg);
+	return nativeResponseValue;
+}
+	// uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
+/* @internal */
+export function RouteHop_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
+/* @internal */
+export function RouteHop_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
+	return nativeResponseValue;
+}
+	// uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
+/* @internal */
+export function RouteHop_hash(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_hash(o);
+	return nativeResponseValue;
+}
+	// bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
+/* @internal */
+export function RouteHop_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
+/* @internal */
+export function RouteHop_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
+/* @internal */
+export function RouteHop_read(ser: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHop_read(ser);
+	return nativeResponseValue;
+}
+	// void BlindedTail_free(struct LDKBlindedTail this_obj);
+/* @internal */
+export function BlindedTail_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_free(this_obj);
+	// debug statements here
+}
+	// struct LDKCVec_BlindedHopZ BlindedTail_get_hops(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
+/* @internal */
+export function BlindedTail_get_hops(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_get_hops(this_ptr);
+	return nativeResponseValue;
+}
+	// void BlindedTail_set_hops(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKCVec_BlindedHopZ val);
+/* @internal */
+export function BlindedTail_set_hops(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_set_hops(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKPublicKey BlindedTail_get_blinding_point(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
+/* @internal */
+export function BlindedTail_get_blinding_point(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_get_blinding_point(this_ptr);
+	return nativeResponseValue;
+}
+	// void BlindedTail_set_blinding_point(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+/* @internal */
+export function BlindedTail_set_blinding_point(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_set_blinding_point(this_ptr, val);
+	// debug statements here
+}
+	// uint32_t BlindedTail_get_excess_final_cltv_expiry_delta(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
+/* @internal */
+export function BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr);
+	return nativeResponseValue;
+}
+	// void BlindedTail_set_excess_final_cltv_expiry_delta(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint32_t val);
+/* @internal */
+export function BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t BlindedTail_get_final_value_msat(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
+/* @internal */
+export function BlindedTail_get_final_value_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_get_final_value_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void BlindedTail_set_final_value_msat(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function BlindedTail_set_final_value_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_set_final_value_msat(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKBlindedTail BlindedTail_new(struct LDKCVec_BlindedHopZ hops_arg, struct LDKPublicKey blinding_point_arg, uint32_t excess_final_cltv_expiry_delta_arg, uint64_t final_value_msat_arg);
+/* @internal */
+export function BlindedTail_new(hops_arg: number, blinding_point_arg: number, excess_final_cltv_expiry_delta_arg: number, final_value_msat_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_new(hops_arg, blinding_point_arg, excess_final_cltv_expiry_delta_arg, final_value_msat_arg);
+	return nativeResponseValue;
+}
+	// uint64_t BlindedTail_clone_ptr(LDKBlindedTail *NONNULL_PTR arg);
+/* @internal */
+export function BlindedTail_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKBlindedTail BlindedTail_clone(const struct LDKBlindedTail *NONNULL_PTR orig);
+/* @internal */
+export function BlindedTail_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_clone(orig);
+	return nativeResponseValue;
+}
+	// uint64_t BlindedTail_hash(const struct LDKBlindedTail *NONNULL_PTR o);
+/* @internal */
+export function BlindedTail_hash(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_hash(o);
+	return nativeResponseValue;
+}
+	// bool BlindedTail_eq(const struct LDKBlindedTail *NONNULL_PTR a, const struct LDKBlindedTail *NONNULL_PTR b);
+/* @internal */
+export function BlindedTail_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_eq(a, b);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z BlindedTail_write(const struct LDKBlindedTail *NONNULL_PTR obj);
+/* @internal */
+export function BlindedTail_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_BlindedTailDecodeErrorZ BlindedTail_read(struct LDKu8slice ser);
+/* @internal */
+export function BlindedTail_read(ser: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_BlindedTail_read(ser);
+	return nativeResponseValue;
+}
+	// void Path_free(struct LDKPath this_obj);
+/* @internal */
+export function Path_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_free(this_obj);
+	// debug statements here
+}
+	// struct LDKCVec_RouteHopZ Path_get_hops(const struct LDKPath *NONNULL_PTR this_ptr);
+/* @internal */
+export function Path_get_hops(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_get_hops(this_ptr);
+	return nativeResponseValue;
+}
+	// void Path_set_hops(struct LDKPath *NONNULL_PTR this_ptr, struct LDKCVec_RouteHopZ val);
+/* @internal */
+export function Path_set_hops(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_set_hops(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKBlindedTail Path_get_blinded_tail(const struct LDKPath *NONNULL_PTR this_ptr);
+/* @internal */
+export function Path_get_blinded_tail(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_get_blinded_tail(this_ptr);
+	return nativeResponseValue;
+}
+	// void Path_set_blinded_tail(struct LDKPath *NONNULL_PTR this_ptr, struct LDKBlindedTail val);
+/* @internal */
+export function Path_set_blinded_tail(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_set_blinded_tail(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKPath Path_new(struct LDKCVec_RouteHopZ hops_arg, struct LDKBlindedTail blinded_tail_arg);
+/* @internal */
+export function Path_new(hops_arg: number, blinded_tail_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_new(hops_arg, blinded_tail_arg);
+	return nativeResponseValue;
+}
+	// uint64_t Path_clone_ptr(LDKPath *NONNULL_PTR arg);
+/* @internal */
+export function Path_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKPath Path_clone(const struct LDKPath *NONNULL_PTR orig);
+/* @internal */
+export function Path_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_clone(orig);
+	return nativeResponseValue;
+}
+	// uint64_t Path_hash(const struct LDKPath *NONNULL_PTR o);
+/* @internal */
+export function Path_hash(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_hash(o);
+	return nativeResponseValue;
+}
+	// bool Path_eq(const struct LDKPath *NONNULL_PTR a, const struct LDKPath *NONNULL_PTR b);
+/* @internal */
+export function Path_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_eq(a, b);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES uint64_t Path_fee_msat(const struct LDKPath *NONNULL_PTR this_arg);
+/* @internal */
+export function Path_fee_msat(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_fee_msat(this_arg);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES uint64_t Path_final_value_msat(const struct LDKPath *NONNULL_PTR this_arg);
+/* @internal */
+export function Path_final_value_msat(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_final_value_msat(this_arg);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKCOption_u32Z Path_final_cltv_expiry_delta(const struct LDKPath *NONNULL_PTR this_arg);
+/* @internal */
+export function Path_final_cltv_expiry_delta(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Path_final_cltv_expiry_delta(this_arg);
+	return nativeResponseValue;
+}
+	// void Route_free(struct LDKRoute this_obj);
+/* @internal */
+export function Route_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_free(this_obj);
+	// debug statements here
+}
+	// struct LDKCVec_PathZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
+/* @internal */
+export function Route_get_paths(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
+	return nativeResponseValue;
+}
+	// void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_PathZ val);
+/* @internal */
+export function Route_set_paths(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
+/* @internal */
+export function Route_get_payment_params(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
+	return nativeResponseValue;
+}
+	// void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
+/* @internal */
+export function Route_set_payment_params(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_PathZ paths_arg, struct LDKPaymentParameters payment_params_arg);
+/* @internal */
+export function Route_new(paths_arg: number, payment_params_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
+	return nativeResponseValue;
+}
+	// uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
+/* @internal */
+export function Route_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
+/* @internal */
+export function Route_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_clone(orig);
+	return nativeResponseValue;
+}
+	// uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
+/* @internal */
+export function Route_hash(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_hash(o);
+	return nativeResponseValue;
+}
+	// bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
+/* @internal */
+export function Route_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_eq(a, b);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
+/* @internal */
+export function Route_get_total_fees(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
+/* @internal */
+export function Route_get_total_amount(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
+/* @internal */
+export function Route_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
+/* @internal */
+export function Route_read(ser: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Route_read(ser);
+	return nativeResponseValue;
+}
+	// void RouteParameters_free(struct LDKRouteParameters this_obj);
+/* @internal */
+export function RouteParameters_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
+	// debug statements here
+}
+	// struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
+/* @internal */
+export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKRouteParameters RouteParameters_new(struct LDKPaymentParameters payment_params_arg, uint64_t final_value_msat_arg);
+/* @internal */
+export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg);
+	return nativeResponseValue;
+}
+	// uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
+/* @internal */
+export function RouteParameters_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
+/* @internal */
+export function RouteParameters_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
+	return nativeResponseValue;
+}
+	// bool RouteParameters_eq(const struct LDKRouteParameters *NONNULL_PTR a, const struct LDKRouteParameters *NONNULL_PTR b);
+/* @internal */
+export function RouteParameters_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteParameters_eq(a, b);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
+/* @internal */
+export function RouteParameters_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
+/* @internal */
+export function RouteParameters_read(ser: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
+	return nativeResponseValue;
+}
+	// void PaymentParameters_free(struct LDKPaymentParameters this_obj);
+/* @internal */
+export function PaymentParameters_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
+	// debug statements here
+}
+	// struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function PaymentParameters_get_payee_pubkey(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
+	return nativeResponseValue;
+}
+	// void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+/* @internal */
+export function PaymentParameters_set_payee_pubkey(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function PaymentParameters_get_features(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
+	return nativeResponseValue;
+}
+	// void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
+/* @internal */
+export function PaymentParameters_set_features(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKHints PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function PaymentParameters_get_route_hints(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
+	return nativeResponseValue;
+}
+	// void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKHints val);
+/* @internal */
+export function PaymentParameters_set_route_hints(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
+	return nativeResponseValue;
+}
+	// void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+/* @internal */
+export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
+	// debug statements here
+}
+	// uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
+	return nativeResponseValue;
+}
+	// void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
+/* @internal */
+export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
+	// debug statements here
+}
+	// uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
+	return nativeResponseValue;
+}
+	// void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
+/* @internal */
+export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
+	// debug statements here
+}
+	// uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
+	return nativeResponseValue;
+}
+	// void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
+/* @internal */
+export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
+	return nativeResponseValue;
+}
+	// void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
+/* @internal */
+export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
+	// debug statements here
+}
+	// uint32_t PaymentParameters_get_final_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function PaymentParameters_get_final_cltv_expiry_delta(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_get_final_cltv_expiry_delta(this_ptr);
+	return nativeResponseValue;
+}
+	// void PaymentParameters_set_final_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
+/* @internal */
+export function PaymentParameters_set_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_set_final_cltv_expiry_delta(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPublicKey payee_pubkey_arg, struct LDKInvoiceFeatures features_arg, struct LDKHints route_hints_arg, struct LDKCOption_u64Z expiry_time_arg, uint32_t max_total_cltv_expiry_delta_arg, uint8_t max_path_count_arg, uint8_t max_channel_saturation_power_of_half_arg, struct LDKCVec_u64Z previously_failed_channels_arg, uint32_t final_cltv_expiry_delta_arg);
+/* @internal */
+export function PaymentParameters_new(payee_pubkey_arg: number, features_arg: bigint, route_hints_arg: bigint, expiry_time_arg: bigint, max_total_cltv_expiry_delta_arg: number, max_path_count_arg: number, max_channel_saturation_power_of_half_arg: number, previously_failed_channels_arg: number, final_cltv_expiry_delta_arg: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg, max_path_count_arg, max_channel_saturation_power_of_half_arg, previously_failed_channels_arg, final_cltv_expiry_delta_arg);
+	return nativeResponseValue;
+}
+	// uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
+/* @internal */
+export function PaymentParameters_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
+/* @internal */
+export function PaymentParameters_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
+	return nativeResponseValue;
+}
+	// uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
+/* @internal */
+export function PaymentParameters_hash(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
+	return nativeResponseValue;
+}
+	// bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
+/* @internal */
+export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
+/* @internal */
+export function PaymentParameters_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser, uint32_t arg);
+/* @internal */
+export function PaymentParameters_read(ser: number, arg: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_read(ser, arg);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta);
+/* @internal */
+export function PaymentParameters_from_node_id(payee_pubkey: number, final_cltv_expiry_delta: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey, final_cltv_expiry_delta);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta);
+/* @internal */
+export function PaymentParameters_for_keysend(payee_pubkey: number, final_cltv_expiry_delta: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey, final_cltv_expiry_delta);
+	return nativeResponseValue;
+}
+	// void Hints_free(struct LDKHints this_ptr);
+/* @internal */
+export function Hints_free(this_ptr: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Hints_free(this_ptr);
+	// debug statements here
+}
+	// uint64_t Hints_clone_ptr(LDKHints *NONNULL_PTR arg);
+/* @internal */
+export function Hints_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Hints_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKHints Hints_clone(const struct LDKHints *NONNULL_PTR orig);
+/* @internal */
+export function Hints_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Hints_clone(orig);
+	return nativeResponseValue;
+}
+	// struct LDKHints Hints_blinded(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ a);
+/* @internal */
+export function Hints_blinded(a: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Hints_blinded(a);
+	return nativeResponseValue;
+}
+	// struct LDKHints Hints_clear(struct LDKCVec_RouteHintZ a);
+/* @internal */
+export function Hints_clear(a: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Hints_clear(a);
+	return nativeResponseValue;
+}
+	// uint64_t Hints_hash(const struct LDKHints *NONNULL_PTR o);
+/* @internal */
+export function Hints_hash(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Hints_hash(o);
+	return nativeResponseValue;
+}
+	// bool Hints_eq(const struct LDKHints *NONNULL_PTR a, const struct LDKHints *NONNULL_PTR b);
+/* @internal */
+export function Hints_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Hints_eq(a, b);
+	return nativeResponseValue;
+}
+	// void RouteHint_free(struct LDKRouteHint this_obj);
+/* @internal */
+export function RouteHint_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
+	// debug statements here
+}
+	// struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHint_get_a(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
+/* @internal */
+export function RouteHint_set_a(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
+/* @internal */
+export function RouteHint_new(a_arg: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
+	return nativeResponseValue;
+}
+	// uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
+/* @internal */
+export function RouteHint_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
+/* @internal */
+export function RouteHint_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
+	return nativeResponseValue;
+}
+	// uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
+/* @internal */
+export function RouteHint_hash(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHint_hash(o);
+	return nativeResponseValue;
+}
+	// bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
+/* @internal */
+export function RouteHint_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
+/* @internal */
+export function RouteHint_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHint_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
+/* @internal */
+export function RouteHint_read(ser: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHint_read(ser);
+	return nativeResponseValue;
+}
+	// void RouteHintHop_free(struct LDKRouteHintHop this_obj);
+/* @internal */
+export function RouteHintHop_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
+	// debug statements here
+}
+	// struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+/* @internal */
+export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
+/* @internal */
+export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
+	// debug statements here
+}
+	// uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
+/* @internal */
+export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+/* @internal */
+export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+/* @internal */
+export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKRouteHintHop RouteHintHop_new(struct LDKPublicKey src_node_id_arg, uint64_t short_channel_id_arg, struct LDKRoutingFees fees_arg, uint16_t cltv_expiry_delta_arg, struct LDKCOption_u64Z htlc_minimum_msat_arg, struct LDKCOption_u64Z htlc_maximum_msat_arg);
+/* @internal */
+export function RouteHintHop_new(src_node_id_arg: number, short_channel_id_arg: bigint, fees_arg: bigint, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_new(src_node_id_arg, short_channel_id_arg, fees_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg);
+	return nativeResponseValue;
+}
+	// uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
+/* @internal */
+export function RouteHintHop_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
+/* @internal */
+export function RouteHintHop_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
+	return nativeResponseValue;
+}
+	// uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
+/* @internal */
+export function RouteHintHop_hash(o: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
+	return nativeResponseValue;
+}
+	// bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
+/* @internal */
+export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
+/* @internal */
+export function RouteHintHop_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
+/* @internal */
+export function RouteHintHop_read(ser: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_RouteLightningErrorZ find_route(struct LDKPublicKey our_node_pubkey, const struct LDKRouteParameters *NONNULL_PTR route_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKLogger logger, const struct LDKScore *NONNULL_PTR scorer, const uint8_t (*random_seed_bytes)[32]);
+/* @internal */
+export function find_route(our_node_pubkey: number, route_params: bigint, network_graph: bigint, first_hops: number, logger: bigint, scorer: bigint, random_seed_bytes: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_RouteLightningErrorZ build_route_from_hops(struct LDKPublicKey our_node_pubkey, struct LDKCVec_PublicKeyZ hops, const struct LDKRouteParameters *NONNULL_PTR route_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, const uint8_t (*random_seed_bytes)[32]);
+/* @internal */
+export function build_route_from_hops(our_node_pubkey: number, hops: number, route_params: bigint, network_graph: bigint, logger: bigint, random_seed_bytes: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
+	return nativeResponseValue;
+}
+	// void Score_free(struct LDKScore this_ptr);
+/* @internal */
+export function Score_free(this_ptr: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Score_free(this_ptr);
+	// debug statements here
+}
+	// void LockableScore_free(struct LDKLockableScore this_ptr);
+/* @internal */
+export function LockableScore_free(this_ptr: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
+	// debug statements here
+}
+	// void WriteableScore_free(struct LDKWriteableScore this_ptr);
+/* @internal */
+export function WriteableScore_free(this_ptr: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_WriteableScore_free(this_ptr);
+	// debug statements here
+}
+	// void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
+/* @internal */
+export function MultiThreadedLockableScore_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
+	// debug statements here
+}
+	// void MultiThreadedScoreLock_free(struct LDKMultiThreadedScoreLock this_obj);
+/* @internal */
+export function MultiThreadedScoreLock_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_free(this_obj);
+	// debug statements here
+}
+	// struct LDKScore MultiThreadedScoreLock_as_Score(const struct LDKMultiThreadedScoreLock *NONNULL_PTR this_arg);
+/* @internal */
+export function MultiThreadedScoreLock_as_Score(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_as_Score(this_arg);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z MultiThreadedScoreLock_write(const struct LDKMultiThreadedScoreLock *NONNULL_PTR obj);
+/* @internal */
+export function MultiThreadedScoreLock_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKLockableScore MultiThreadedLockableScore_as_LockableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
+/* @internal */
+export function MultiThreadedLockableScore_as_LockableScore(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_LockableScore(this_arg);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
+/* @internal */
+export function MultiThreadedLockableScore_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKWriteableScore MultiThreadedLockableScore_as_WriteableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
+/* @internal */
+export function MultiThreadedLockableScore_as_WriteableScore(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_WriteableScore(this_arg);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
+/* @internal */
+export function MultiThreadedLockableScore_new(score: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
+	return nativeResponseValue;
+}
+	// void ChannelUsage_free(struct LDKChannelUsage this_obj);
+/* @internal */
+export function ChannelUsage_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
+	// debug statements here
+}
+	// uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
+	// debug statements here
+}
+	// struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
+	return nativeResponseValue;
+}
+	// void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
+/* @internal */
+export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
+/* @internal */
+export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
+	return nativeResponseValue;
+}
+	// uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
+/* @internal */
+export function ChannelUsage_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
+/* @internal */
+export function ChannelUsage_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
+	return nativeResponseValue;
+}
+	// void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
+/* @internal */
+export function FixedPenaltyScorer_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
+	// debug statements here
+}
+	// uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
+/* @internal */
+export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
+/* @internal */
+export function FixedPenaltyScorer_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
+/* @internal */
+export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
+	return nativeResponseValue;
+}
+	// struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
+/* @internal */
+export function FixedPenaltyScorer_as_Score(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
+	return nativeResponseValue;
+}
+	// struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
+/* @internal */
+export function FixedPenaltyScorer_write(obj: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
+	return nativeResponseValue;
+}
+	// struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
+/* @internal */
+export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
+/* @internal */
+export function ProbabilisticScorer_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
+	// debug statements here
+}
+	// void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
+/* @internal */
+export function ProbabilisticScoringParameters_free(this_obj: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
+	// debug statements here
+}
+	// uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ProbabilisticScoringParameters_get_historical_no_updates_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ProbabilisticScoringParameters_get_historical_no_updates_half_life(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_no_updates_half_life(this_ptr);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScoringParameters_set_historical_no_updates_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ProbabilisticScoringParameters_set_historical_no_updates_half_life(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_no_updates_half_life(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr, val);
+	// debug statements here
+}
+	// uint64_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
+/* @internal */
+export function ProbabilisticScoringParameters_clone_ptr(arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
+	return nativeResponseValue;
+}
+	// struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
+/* @internal */
+export function ProbabilisticScoringParameters_clone(orig: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
+/* @internal */
+export function ProbabilisticScorer_new(params: bigint, network_graph: bigint, logger: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
+/* @internal */
+export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
+	// debug statements here
+}
+	// MUST_USE_RES struct LDKCOption_C2Tuple_u64u64ZZ ProbabilisticScorer_estimated_channel_liquidity_range(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target);
+/* @internal */
+export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
+	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKCOption_C2Tuple_EightU16sEightU16sZZ ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target);
+/* @internal */
+export function ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg: bigint, scid: bigint, target: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg, scid, target);
+	return nativeResponseValue;
+}
+	// void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
+/* @internal */
+export function ProbabilisticScorer_add_banned(this_arg: bigint, node_id: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_add_banned(this_arg, node_id);
+	// debug statements here
+}
+	// void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
+/* @internal */
+export function ProbabilisticScorer_remove_banned(this_arg: bigint, node_id: bigint): void {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_banned(this_arg, node_id);
+	// debug statements here
+}
+	// void ProbabilisticScorer_set_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
 /* @internal */
-export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
+export function ProbabilisticScorer_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_set_manual_penalty(this_arg, node_id, penalty);
+	// debug statements here
 }
-	// void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
+	// void ProbabilisticScorer_remove_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
 /* @internal */
-export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
+export function ProbabilisticScorer_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_manual_penalty(this_arg, node_id);
 	// debug statements here
 }
-	// uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+	// void ProbabilisticScorer_clear_manual_penalties(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
 /* @internal */
-export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
+export function ProbabilisticScorer_clear_manual_penalties(this_arg: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_clear_manual_penalties(this_arg);
+	// debug statements here
 }
-	// void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
+	// void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
 /* @internal */
-export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
+export function ProbabilisticScoringParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_add_banned_from_list(this_arg, node_ids);
 	// debug statements here
 }
-	// uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+	// MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
 /* @internal */
-export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
+export function ProbabilisticScoringParameters_default(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
+	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
 	return nativeResponseValue;
 }
-	// void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
+	// struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
 /* @internal */
-export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
+export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
+	return nativeResponseValue;
 }
-	// struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+	// struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
 /* @internal */
-export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
+export function ProbabilisticScorer_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
 	return nativeResponseValue;
 }
-	// void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
+	// struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
 /* @internal */
-export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
+export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
+	return nativeResponseValue;
 }
-	// uint32_t PaymentParameters_get_final_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+	// void OnionMessenger_free(struct LDKOnionMessenger this_obj);
 /* @internal */
-export function PaymentParameters_get_final_cltv_expiry_delta(this_ptr: bigint): number {
+export function OnionMessenger_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_get_final_cltv_expiry_delta(this_ptr);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
+	// debug statements here
 }
-	// void PaymentParameters_set_final_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
+	// void Destination_free(struct LDKDestination this_ptr);
 /* @internal */
-export function PaymentParameters_set_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
+export function Destination_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_set_final_cltv_expiry_delta(this_ptr, val);
+	const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPublicKey payee_pubkey_arg, struct LDKInvoiceFeatures features_arg, struct LDKCVec_RouteHintZ route_hints_arg, struct LDKCOption_u64Z expiry_time_arg, uint32_t max_total_cltv_expiry_delta_arg, uint8_t max_path_count_arg, uint8_t max_channel_saturation_power_of_half_arg, struct LDKCVec_u64Z previously_failed_channels_arg, uint32_t final_cltv_expiry_delta_arg);
+	// uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg);
 /* @internal */
-export function PaymentParameters_new(payee_pubkey_arg: number, features_arg: bigint, route_hints_arg: number, expiry_time_arg: bigint, max_total_cltv_expiry_delta_arg: number, max_path_count_arg: number, max_channel_saturation_power_of_half_arg: number, previously_failed_channels_arg: number, final_cltv_expiry_delta_arg: number): bigint {
+export function Destination_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg, max_path_count_arg, max_channel_saturation_power_of_half_arg, previously_failed_channels_arg, final_cltv_expiry_delta_arg);
+	const nativeResponseValue = wasm.TS_Destination_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
+	// struct LDKDestination Destination_clone(const struct LDKDestination *NONNULL_PTR orig);
 /* @internal */
-export function PaymentParameters_clone_ptr(arg: bigint): bigint {
+export function Destination_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_Destination_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
+	// struct LDKDestination Destination_node(struct LDKPublicKey a);
 /* @internal */
-export function PaymentParameters_clone(orig: bigint): bigint {
+export function Destination_node(a: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
+	const nativeResponseValue = wasm.TS_Destination_node(a);
 	return nativeResponseValue;
 }
-	// uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
+	// struct LDKDestination Destination_blinded_path(struct LDKBlindedPath a);
 /* @internal */
-export function PaymentParameters_hash(o: bigint): bigint {
+export function Destination_blinded_path(a: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
+	const nativeResponseValue = wasm.TS_Destination_blinded_path(a);
 	return nativeResponseValue;
 }
-	// bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
+	// void SendError_free(struct LDKSendError this_ptr);
 /* @internal */
-export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
+export function SendError_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
+	// debug statements here
 }
-	// struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
+	// uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
 /* @internal */
-export function PaymentParameters_write(obj: bigint): number {
+export function SendError_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
+	const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser, uint32_t arg);
+	// struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
 /* @internal */
-export function PaymentParameters_read(ser: number, arg: number): bigint {
+export function SendError_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_read(ser, arg);
+	const nativeResponseValue = wasm.TS_SendError_clone(orig);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta);
+	// struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
 /* @internal */
-export function PaymentParameters_from_node_id(payee_pubkey: number, final_cltv_expiry_delta: number): bigint {
+export function SendError_secp256k1(a: Secp256k1Error): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey, final_cltv_expiry_delta);
+	const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta);
+	// struct LDKSendError SendError_too_big_packet(void);
 /* @internal */
-export function PaymentParameters_for_keysend(payee_pubkey: number, final_cltv_expiry_delta: number): bigint {
+export function SendError_too_big_packet(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey, final_cltv_expiry_delta);
+	const nativeResponseValue = wasm.TS_SendError_too_big_packet();
 	return nativeResponseValue;
 }
-	// void RouteHint_free(struct LDKRouteHint this_obj);
+	// struct LDKSendError SendError_too_few_blinded_hops(void);
 /* @internal */
-export function RouteHint_free(this_obj: bigint): void {
+export function SendError_too_few_blinded_hops(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
+	return nativeResponseValue;
 }
-	// struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
+	// struct LDKSendError SendError_invalid_first_hop(void);
 /* @internal */
-export function RouteHint_get_a(this_ptr: bigint): number {
+export function SendError_invalid_first_hop(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
+	const nativeResponseValue = wasm.TS_SendError_invalid_first_hop();
 	return nativeResponseValue;
 }
-	// void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
+	// struct LDKSendError SendError_invalid_message(void);
 /* @internal */
-export function RouteHint_set_a(this_ptr: bigint, val: number): void {
+export function SendError_invalid_message(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_SendError_invalid_message();
+	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
+	// struct LDKSendError SendError_buffer_full(void);
 /* @internal */
-export function RouteHint_new(a_arg: number): bigint {
+export function SendError_buffer_full(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
+	const nativeResponseValue = wasm.TS_SendError_buffer_full();
 	return nativeResponseValue;
 }
-	// uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
+	// struct LDKSendError SendError_get_node_id_failed(void);
 /* @internal */
-export function RouteHint_clone_ptr(arg: bigint): bigint {
+export function SendError_get_node_id_failed(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_SendError_get_node_id_failed();
 	return nativeResponseValue;
 }
-	// struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
+	// struct LDKSendError SendError_blinded_path_advance_failed(void);
 /* @internal */
-export function RouteHint_clone(orig: bigint): bigint {
+export function SendError_blinded_path_advance_failed(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
+	const nativeResponseValue = wasm.TS_SendError_blinded_path_advance_failed();
 	return nativeResponseValue;
 }
-	// uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
+	// bool SendError_eq(const struct LDKSendError *NONNULL_PTR a, const struct LDKSendError *NONNULL_PTR b);
 /* @internal */
-export function RouteHint_hash(o: bigint): bigint {
+export function SendError_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHint_hash(o);
+	const nativeResponseValue = wasm.TS_SendError_eq(a, b);
 	return nativeResponseValue;
 }
-	// bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
+	// void CustomOnionMessageHandler_free(struct LDKCustomOnionMessageHandler this_ptr);
 /* @internal */
-export function RouteHint_eq(a: bigint, b: bigint): boolean {
+export function CustomOnionMessageHandler_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_free(this_ptr);
+	// debug statements here
 }
-	// struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
+	// MUST_USE_RES struct LDKOnionMessenger OnionMessenger_new(struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, struct LDKCustomOnionMessageHandler custom_handler);
 /* @internal */
-export function RouteHint_write(obj: bigint): number {
+export function OnionMessenger_new(entropy_source: bigint, node_signer: bigint, logger: bigint, custom_handler: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHint_write(obj);
+	const nativeResponseValue = wasm.TS_OnionMessenger_new(entropy_source, node_signer, logger, custom_handler);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
+	// MUST_USE_RES struct LDKCResult_NoneSendErrorZ OnionMessenger_send_onion_message(const struct LDKOnionMessenger *NONNULL_PTR this_arg, struct LDKCVec_PublicKeyZ intermediate_nodes, struct LDKDestination destination, struct LDKOnionMessageContents message, struct LDKBlindedPath reply_path);
 /* @internal */
-export function RouteHint_read(ser: number): bigint {
+export function OnionMessenger_send_onion_message(this_arg: bigint, intermediate_nodes: number, destination: bigint, message: bigint, reply_path: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHint_read(ser);
+	const nativeResponseValue = wasm.TS_OnionMessenger_send_onion_message(this_arg, intermediate_nodes, destination, message, reply_path);
 	return nativeResponseValue;
 }
-	// void RouteHintHop_free(struct LDKRouteHintHop this_obj);
+	// struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
 /* @internal */
-export function RouteHintHop_free(this_obj: bigint): void {
+export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
+	return nativeResponseValue;
 }
-	// struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
+	// struct LDKOnionMessageProvider OnionMessenger_as_OnionMessageProvider(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
 /* @internal */
-export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
+export function OnionMessenger_as_OnionMessageProvider(this_arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
+	const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageProvider(this_arg);
 	return nativeResponseValue;
 }
-	// void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+	// void OnionMessageContents_free(struct LDKOnionMessageContents this_ptr);
 /* @internal */
-export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
+export function OnionMessageContents_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
+	const nativeResponseValue = wasm.TS_OnionMessageContents_free(this_ptr);
 	// debug statements here
 }
-	// uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
+	// uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg);
 /* @internal */
-export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
+export function OnionMessageContents_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
+	const nativeResponseValue = wasm.TS_OnionMessageContents_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
+	// struct LDKOnionMessageContents OnionMessageContents_clone(const struct LDKOnionMessageContents *NONNULL_PTR orig);
 /* @internal */
-export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
+export function OnionMessageContents_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_OnionMessageContents_clone(orig);
+	return nativeResponseValue;
 }
-	// struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
+	// struct LDKOnionMessageContents OnionMessageContents_custom(struct LDKCustomOnionMessageContents a);
 /* @internal */
-export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
+export function OnionMessageContents_custom(a: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
+	const nativeResponseValue = wasm.TS_OnionMessageContents_custom(a);
 	return nativeResponseValue;
 }
-	// void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
+	// uint64_t CustomOnionMessageContents_clone_ptr(LDKCustomOnionMessageContents *NONNULL_PTR arg);
 /* @internal */
-export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
+export function CustomOnionMessageContents_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone_ptr(arg);
+	return nativeResponseValue;
 }
-	// uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
+	// struct LDKCustomOnionMessageContents CustomOnionMessageContents_clone(const struct LDKCustomOnionMessageContents *NONNULL_PTR orig);
 /* @internal */
-export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
+export function CustomOnionMessageContents_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
+	const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone(orig);
 	return nativeResponseValue;
 }
-	// void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
+	// void CustomOnionMessageContents_free(struct LDKCustomOnionMessageContents this_ptr);
 /* @internal */
-export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
+export function CustomOnionMessageContents_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
+	const nativeResponseValue = wasm.TS_CustomOnionMessageContents_free(this_ptr);
 	// debug statements here
 }
-	// struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
-/* @internal */
-export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
-	return nativeResponseValue;
-}
-	// void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+	// void BlindedPath_free(struct LDKBlindedPath this_obj);
 /* @internal */
-export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
+export function BlindedPath_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
+	const nativeResponseValue = wasm.TS_BlindedPath_free(this_obj);
 	// debug statements here
 }
-	// struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
+	// uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg);
 /* @internal */
-export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
+export function BlindedPath_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_BlindedPath_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+	// struct LDKBlindedPath BlindedPath_clone(const struct LDKBlindedPath *NONNULL_PTR orig);
 /* @internal */
-export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
+export function BlindedPath_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_BlindedPath_clone(orig);
+	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKRouteHintHop RouteHintHop_new(struct LDKPublicKey src_node_id_arg, uint64_t short_channel_id_arg, struct LDKRoutingFees fees_arg, uint16_t cltv_expiry_delta_arg, struct LDKCOption_u64Z htlc_minimum_msat_arg, struct LDKCOption_u64Z htlc_maximum_msat_arg);
+	// uint64_t BlindedPath_hash(const struct LDKBlindedPath *NONNULL_PTR o);
 /* @internal */
-export function RouteHintHop_new(src_node_id_arg: number, short_channel_id_arg: bigint, fees_arg: bigint, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint): bigint {
+export function BlindedPath_hash(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_new(src_node_id_arg, short_channel_id_arg, fees_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg);
+	const nativeResponseValue = wasm.TS_BlindedPath_hash(o);
 	return nativeResponseValue;
 }
-	// uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
+	// bool BlindedPath_eq(const struct LDKBlindedPath *NONNULL_PTR a, const struct LDKBlindedPath *NONNULL_PTR b);
 /* @internal */
-export function RouteHintHop_clone_ptr(arg: bigint): bigint {
+export function BlindedPath_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_BlindedPath_eq(a, b);
 	return nativeResponseValue;
 }
-	// struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
+	// void BlindedHop_free(struct LDKBlindedHop this_obj);
 /* @internal */
-export function RouteHintHop_clone(orig: bigint): bigint {
+export function BlindedHop_free(this_obj: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
+	// debug statements here
 }
-	// uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
+	// uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg);
 /* @internal */
-export function RouteHintHop_hash(o: bigint): bigint {
+export function BlindedHop_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
+	const nativeResponseValue = wasm.TS_BlindedHop_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
+	// struct LDKBlindedHop BlindedHop_clone(const struct LDKBlindedHop *NONNULL_PTR orig);
 /* @internal */
-export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
+export function BlindedHop_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
+	const nativeResponseValue = wasm.TS_BlindedHop_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
+	// uint64_t BlindedHop_hash(const struct LDKBlindedHop *NONNULL_PTR o);
 /* @internal */
-export function RouteHintHop_write(obj: bigint): number {
+export function BlindedHop_hash(o: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
+	const nativeResponseValue = wasm.TS_BlindedHop_hash(o);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
+	// bool BlindedHop_eq(const struct LDKBlindedHop *NONNULL_PTR a, const struct LDKBlindedHop *NONNULL_PTR b);
 /* @internal */
-export function RouteHintHop_read(ser: number): bigint {
+export function BlindedHop_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
+	const nativeResponseValue = wasm.TS_BlindedHop_eq(a, b);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_RouteLightningErrorZ find_route(struct LDKPublicKey our_node_pubkey, const struct LDKRouteParameters *NONNULL_PTR route_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKLogger logger, const struct LDKScore *NONNULL_PTR scorer, const uint8_t (*random_seed_bytes)[32]);
+	// MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_new_for_message(struct LDKCVec_PublicKeyZ node_pks, const struct LDKEntropySource *NONNULL_PTR entropy_source);
 /* @internal */
-export function find_route(our_node_pubkey: number, route_params: bigint, network_graph: bigint, first_hops: number, logger: bigint, scorer: bigint, random_seed_bytes: number): bigint {
+export function BlindedPath_new_for_message(node_pks: number, entropy_source: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
+	const nativeResponseValue = wasm.TS_BlindedPath_new_for_message(node_pks, entropy_source);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_RouteLightningErrorZ build_route_from_hops(struct LDKPublicKey our_node_pubkey, struct LDKCVec_PublicKeyZ hops, const struct LDKRouteParameters *NONNULL_PTR route_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, const uint8_t (*random_seed_bytes)[32]);
+	// struct LDKCVec_u8Z BlindedPath_write(const struct LDKBlindedPath *NONNULL_PTR obj);
 /* @internal */
-export function build_route_from_hops(our_node_pubkey: number, hops: number, route_params: bigint, network_graph: bigint, logger: bigint, random_seed_bytes: number): bigint {
+export function BlindedPath_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
+	const nativeResponseValue = wasm.TS_BlindedPath_write(obj);
 	return nativeResponseValue;
 }
-	// void Score_free(struct LDKScore this_ptr);
+	// struct LDKCResult_BlindedPathDecodeErrorZ BlindedPath_read(struct LDKu8slice ser);
 /* @internal */
-export function Score_free(this_ptr: bigint): void {
+export function BlindedPath_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Score_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_BlindedPath_read(ser);
+	return nativeResponseValue;
 }
-	// void LockableScore_free(struct LDKLockableScore this_ptr);
+	// struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
 /* @internal */
-export function LockableScore_free(this_ptr: bigint): void {
+export function BlindedHop_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
+	return nativeResponseValue;
 }
-	// void WriteableScore_free(struct LDKWriteableScore this_ptr);
+	// struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
 /* @internal */
-export function WriteableScore_free(this_ptr: bigint): void {
+export function BlindedHop_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_WriteableScore_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
+	return nativeResponseValue;
 }
-	// void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
+	// void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
 /* @internal */
-export function MultiThreadedLockableScore_free(this_obj: bigint): void {
+export function PaymentPurpose_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
+	const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
 	// debug statements here
 }
-	// void MultiThreadedScoreLock_free(struct LDKMultiThreadedScoreLock this_obj);
+	// uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
 /* @internal */
-export function MultiThreadedScoreLock_free(this_obj: bigint): void {
+export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
+	return nativeResponseValue;
 }
-	// struct LDKScore MultiThreadedScoreLock_as_Score(const struct LDKMultiThreadedScoreLock *NONNULL_PTR this_arg);
+	// struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
 /* @internal */
-export function MultiThreadedScoreLock_as_Score(this_arg: bigint): bigint {
+export function PaymentPurpose_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_as_Score(this_arg);
+	const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z MultiThreadedScoreLock_write(const struct LDKMultiThreadedScoreLock *NONNULL_PTR obj);
+	// struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
 /* @internal */
-export function MultiThreadedScoreLock_write(obj: bigint): number {
+export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_write(obj);
+	const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
 	return nativeResponseValue;
 }
-	// struct LDKLockableScore MultiThreadedLockableScore_as_LockableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
+	// struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
 /* @internal */
-export function MultiThreadedLockableScore_as_LockableScore(this_arg: bigint): bigint {
+export function PaymentPurpose_spontaneous_payment(a: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_LockableScore(this_arg);
+	const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
+	// bool PaymentPurpose_eq(const struct LDKPaymentPurpose *NONNULL_PTR a, const struct LDKPaymentPurpose *NONNULL_PTR b);
 /* @internal */
-export function MultiThreadedLockableScore_write(obj: bigint): number {
+export function PaymentPurpose_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
+	const nativeResponseValue = wasm.TS_PaymentPurpose_eq(a, b);
 	return nativeResponseValue;
 }
-	// struct LDKWriteableScore MultiThreadedLockableScore_as_WriteableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
+	// struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
 /* @internal */
-export function MultiThreadedLockableScore_as_WriteableScore(this_arg: bigint): bigint {
+export function PaymentPurpose_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_WriteableScore(this_arg);
+	const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
+	// struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
 /* @internal */
-export function MultiThreadedLockableScore_new(score: bigint): bigint {
+export function PaymentPurpose_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
+	const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
 	return nativeResponseValue;
 }
-	// void ChannelUsage_free(struct LDKChannelUsage this_obj);
+	// void PathFailure_free(struct LDKPathFailure this_ptr);
 /* @internal */
-export function ChannelUsage_free(this_obj: bigint): void {
+export function PathFailure_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
+	const nativeResponseValue = wasm.TS_PathFailure_free(this_ptr);
 	// debug statements here
 }
-	// uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
+	// uint64_t PathFailure_clone_ptr(LDKPathFailure *NONNULL_PTR arg);
 /* @internal */
-export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
+export function PathFailure_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_PathFailure_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
+	// struct LDKPathFailure PathFailure_clone(const struct LDKPathFailure *NONNULL_PTR orig);
 /* @internal */
-export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
+export function PathFailure_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_PathFailure_clone(orig);
+	return nativeResponseValue;
 }
-	// uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
+	// struct LDKPathFailure PathFailure_initial_send(struct LDKAPIError err);
 /* @internal */
-export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
+export function PathFailure_initial_send(err: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_PathFailure_initial_send(err);
 	return nativeResponseValue;
 }
-	// void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
+	// struct LDKPathFailure PathFailure_on_path(struct LDKCOption_NetworkUpdateZ network_update);
 /* @internal */
-export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
+export function PathFailure_on_path(network_update: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_PathFailure_on_path(network_update);
+	return nativeResponseValue;
 }
-	// struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
+	// bool PathFailure_eq(const struct LDKPathFailure *NONNULL_PTR a, const struct LDKPathFailure *NONNULL_PTR b);
 /* @internal */
-export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
+export function PathFailure_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
+	const nativeResponseValue = wasm.TS_PathFailure_eq(a, b);
 	return nativeResponseValue;
 }
-	// void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
+	// struct LDKCVec_u8Z PathFailure_write(const struct LDKPathFailure *NONNULL_PTR obj);
 /* @internal */
-export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
+export function PathFailure_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_PathFailure_write(obj);
+	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
+	// struct LDKCResult_COption_PathFailureZDecodeErrorZ PathFailure_read(struct LDKu8slice ser);
 /* @internal */
-export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
+export function PathFailure_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
+	const nativeResponseValue = wasm.TS_PathFailure_read(ser);
 	return nativeResponseValue;
 }
-	// uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
+	// void ClosureReason_free(struct LDKClosureReason this_ptr);
 /* @internal */
-export function ChannelUsage_clone_ptr(arg: bigint): bigint {
+export function ClosureReason_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
+	// debug statements here
 }
-	// struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
+	// uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
 /* @internal */
-export function ChannelUsage_clone(orig: bigint): bigint {
+export function ClosureReason_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
+	const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
+	// struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
 /* @internal */
-export function FixedPenaltyScorer_free(this_obj: bigint): void {
+export function ClosureReason_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
+	return nativeResponseValue;
 }
-	// uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
+	// struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKUntrustedString peer_msg);
 /* @internal */
-export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
+export function ClosureReason_counterparty_force_closed(peer_msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
 	return nativeResponseValue;
 }
-	// struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
+	// struct LDKClosureReason ClosureReason_holder_force_closed(void);
 /* @internal */
-export function FixedPenaltyScorer_clone(orig: bigint): bigint {
+export function ClosureReason_holder_force_closed(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
+	const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
+	// struct LDKClosureReason ClosureReason_cooperative_closure(void);
 /* @internal */
-export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
+export function ClosureReason_cooperative_closure(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
+	const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
 	return nativeResponseValue;
 }
-	// struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
+	// struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
 /* @internal */
-export function FixedPenaltyScorer_as_Score(this_arg: bigint): bigint {
+export function ClosureReason_commitment_tx_confirmed(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
+	const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
+	// struct LDKClosureReason ClosureReason_funding_timed_out(void);
 /* @internal */
-export function FixedPenaltyScorer_write(obj: bigint): number {
+export function ClosureReason_funding_timed_out(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
+	const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
 	return nativeResponseValue;
 }
-	// struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
+	// struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
 /* @internal */
-export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
+export function ClosureReason_processing_error(err: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
+	const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
 	return nativeResponseValue;
 }
-	// void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
+	// struct LDKClosureReason ClosureReason_disconnected_peer(void);
 /* @internal */
-export function ProbabilisticScorer_free(this_obj: bigint): void {
+export function ClosureReason_disconnected_peer(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
+	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
+	// struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
 /* @internal */
-export function ProbabilisticScoringParameters_free(this_obj: bigint): void {
+export function ClosureReason_outdated_channel_manager(): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
+	return nativeResponseValue;
 }
-	// uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+	// bool ClosureReason_eq(const struct LDKClosureReason *NONNULL_PTR a, const struct LDKClosureReason *NONNULL_PTR b);
 /* @internal */
-export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
+export function ClosureReason_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_ClosureReason_eq(a, b);
 	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+	// struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
 /* @internal */
-export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
+export function ClosureReason_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
+	return nativeResponseValue;
 }
-	// uint64_t ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+	// struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
 /* @internal */
-export function ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
+export function ClosureReason_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
 	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+	// void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
 /* @internal */
-export function ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
+export function HTLCDestination_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
+	const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
 	// debug statements here
 }
-	// uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+	// uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
 /* @internal */
-export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
+export function HTLCDestination_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+	// struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
 /* @internal */
-export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
+export function HTLCDestination_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
+	return nativeResponseValue;
 }
-	// uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+	// struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
 /* @internal */
-export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
+export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
+	const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
 	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+	// struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
 /* @internal */
-export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
+export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
+	return nativeResponseValue;
 }
-	// uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+	// struct LDKHTLCDestination HTLCDestination_invalid_forward(uint64_t requested_forward_scid);
 /* @internal */
-export function ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
+export function HTLCDestination_invalid_forward(requested_forward_scid: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_HTLCDestination_invalid_forward(requested_forward_scid);
 	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+	// struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
 /* @internal */
-export function ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
+export function HTLCDestination_failed_payment(payment_hash: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
+	return nativeResponseValue;
 }
-	// uint64_t ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+	// bool HTLCDestination_eq(const struct LDKHTLCDestination *NONNULL_PTR a, const struct LDKHTLCDestination *NONNULL_PTR b);
 /* @internal */
-export function ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
+export function HTLCDestination_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_HTLCDestination_eq(a, b);
 	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+	// struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
 /* @internal */
-export function ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
+export function HTLCDestination_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
+	return nativeResponseValue;
 }
-	// uint64_t ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+	// struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
 /* @internal */
-export function ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
+export function HTLCDestination_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
 	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+	// enum LDKPaymentFailureReason PaymentFailureReason_clone(const enum LDKPaymentFailureReason *NONNULL_PTR orig);
 /* @internal */
-export function ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
+export function PaymentFailureReason_clone(orig: bigint): PaymentFailureReason {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_PaymentFailureReason_clone(orig);
+	return nativeResponseValue;
 }
-	// uint64_t ProbabilisticScoringParameters_get_historical_no_updates_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+	// enum LDKPaymentFailureReason PaymentFailureReason_recipient_rejected(void);
 /* @internal */
-export function ProbabilisticScoringParameters_get_historical_no_updates_half_life(this_ptr: bigint): bigint {
+export function PaymentFailureReason_recipient_rejected(): PaymentFailureReason {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_historical_no_updates_half_life(this_ptr);
+	const nativeResponseValue = wasm.TS_PaymentFailureReason_recipient_rejected();
 	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_set_historical_no_updates_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+	// enum LDKPaymentFailureReason PaymentFailureReason_user_abandoned(void);
 /* @internal */
-export function ProbabilisticScoringParameters_set_historical_no_updates_half_life(this_ptr: bigint, val: bigint): void {
+export function PaymentFailureReason_user_abandoned(): PaymentFailureReason {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_historical_no_updates_half_life(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_PaymentFailureReason_user_abandoned();
+	return nativeResponseValue;
 }
-	// uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+	// enum LDKPaymentFailureReason PaymentFailureReason_retries_exhausted(void);
 /* @internal */
-export function ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
+export function PaymentFailureReason_retries_exhausted(): PaymentFailureReason {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_PaymentFailureReason_retries_exhausted();
 	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+	// enum LDKPaymentFailureReason PaymentFailureReason_payment_expired(void);
 /* @internal */
-export function ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
+export function PaymentFailureReason_payment_expired(): PaymentFailureReason {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_PaymentFailureReason_payment_expired();
+	return nativeResponseValue;
 }
-	// uint64_t ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+	// enum LDKPaymentFailureReason PaymentFailureReason_route_not_found(void);
 /* @internal */
-export function ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
+export function PaymentFailureReason_route_not_found(): PaymentFailureReason {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr);
+	const nativeResponseValue = wasm.TS_PaymentFailureReason_route_not_found();
 	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
+	// enum LDKPaymentFailureReason PaymentFailureReason_unexpected_error(void);
 /* @internal */
-export function ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
+export function PaymentFailureReason_unexpected_error(): PaymentFailureReason {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr, val);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_PaymentFailureReason_unexpected_error();
+	return nativeResponseValue;
 }
-	// uint64_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
+	// bool PaymentFailureReason_eq(const enum LDKPaymentFailureReason *NONNULL_PTR a, const enum LDKPaymentFailureReason *NONNULL_PTR b);
 /* @internal */
-export function ProbabilisticScoringParameters_clone_ptr(arg: bigint): bigint {
+export function PaymentFailureReason_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_PaymentFailureReason_eq(a, b);
 	return nativeResponseValue;
 }
-	// struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
+	// struct LDKCVec_u8Z PaymentFailureReason_write(const enum LDKPaymentFailureReason *NONNULL_PTR obj);
 /* @internal */
-export function ProbabilisticScoringParameters_clone(orig: bigint): bigint {
+export function PaymentFailureReason_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
+	const nativeResponseValue = wasm.TS_PaymentFailureReason_write(obj);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
+	// struct LDKCResult_PaymentFailureReasonDecodeErrorZ PaymentFailureReason_read(struct LDKu8slice ser);
 /* @internal */
-export function ProbabilisticScorer_new(params: bigint, network_graph: bigint, logger: bigint): bigint {
+export function PaymentFailureReason_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
+	const nativeResponseValue = wasm.TS_PaymentFailureReason_read(ser);
 	return nativeResponseValue;
 }
-	// void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
+	// void Event_free(struct LDKEvent this_ptr);
 /* @internal */
-export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
+export function Event_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
+	const nativeResponseValue = wasm.TS_Event_free(this_ptr);
 	// debug statements here
 }
-	// MUST_USE_RES struct LDKCOption_C2Tuple_u64u64ZZ ProbabilisticScorer_estimated_channel_liquidity_range(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target);
+	// uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
 /* @internal */
-export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
+export function Event_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
+	const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCOption_C2Tuple_EightU16sEightU16sZZ ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target);
+	// struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
 /* @internal */
-export function ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg: bigint, scid: bigint, target: bigint): bigint {
+export function Event_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg, scid, target);
+	const nativeResponseValue = wasm.TS_Event_clone(orig);
 	return nativeResponseValue;
 }
-	// void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
+	// struct LDKEvent Event_funding_generation_ready(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t channel_value_satoshis, struct LDKCVec_u8Z output_script, struct LDKU128 user_channel_id);
 /* @internal */
-export function ProbabilisticScorer_add_banned(this_arg: bigint, node_id: bigint): void {
+export function Event_funding_generation_ready(temporary_channel_id: number, counterparty_node_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_add_banned(this_arg, node_id);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
+	return nativeResponseValue;
 }
-	// void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
+	// struct LDKEvent Event_payment_claimable(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields onion_fields, uint64_t amount_msat, struct LDKPaymentPurpose purpose, struct LDKThirtyTwoBytes via_channel_id, struct LDKCOption_u128Z via_user_channel_id, struct LDKCOption_u32Z claim_deadline);
 /* @internal */
-export function ProbabilisticScorer_remove_banned(this_arg: bigint, node_id: bigint): void {
+export function Event_payment_claimable(receiver_node_id: number, payment_hash: number, onion_fields: bigint, amount_msat: bigint, purpose: bigint, via_channel_id: number, via_user_channel_id: bigint, claim_deadline: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_banned(this_arg, node_id);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Event_payment_claimable(receiver_node_id, payment_hash, onion_fields, amount_msat, purpose, via_channel_id, via_user_channel_id, claim_deadline);
+	return nativeResponseValue;
 }
-	// void ProbabilisticScorer_set_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
+	// struct LDKEvent Event_payment_claimed(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
 /* @internal */
-export function ProbabilisticScorer_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
+export function Event_payment_claimed(receiver_node_id: number, payment_hash: number, amount_msat: bigint, purpose: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_set_manual_penalty(this_arg, node_id, penalty);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Event_payment_claimed(receiver_node_id, payment_hash, amount_msat, purpose);
+	return nativeResponseValue;
 }
-	// void ProbabilisticScorer_remove_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
+	// struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
 /* @internal */
-export function ProbabilisticScorer_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
+export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_manual_penalty(this_arg, node_id);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
+	return nativeResponseValue;
 }
-	// void ProbabilisticScorer_clear_manual_penalties(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
+	// struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_PaymentFailureReasonZ reason);
 /* @internal */
-export function ProbabilisticScorer_clear_manual_penalties(this_arg: bigint): void {
+export function Event_payment_failed(payment_id: number, payment_hash: number, reason: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_clear_manual_penalties(this_arg);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash, reason);
+	return nativeResponseValue;
 }
-	// void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
+	// struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path);
 /* @internal */
-export function ProbabilisticScoringParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
+export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_add_banned_from_list(this_arg, node_ids);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
+	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
+	// struct LDKEvent Event_payment_path_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, bool payment_failed_permanently, struct LDKPathFailure failure, struct LDKPath path, struct LDKCOption_u64Z short_channel_id);
 /* @internal */
-export function ProbabilisticScoringParameters_default(): bigint {
+export function Event_payment_path_failed(payment_id: number, payment_hash: number, payment_failed_permanently: boolean, failure: bigint, path: bigint, short_channel_id: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
+	const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, payment_failed_permanently, failure, path, short_channel_id);
 	return nativeResponseValue;
 }
-	// struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
+	// struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path);
 /* @internal */
-export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
+export function Event_probe_successful(payment_id: number, payment_hash: number, path: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
+	const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
+	// struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path, struct LDKCOption_u64Z short_channel_id);
 /* @internal */
-export function ProbabilisticScorer_write(obj: bigint): number {
+export function Event_probe_failed(payment_id: number, payment_hash: number, path: bigint, short_channel_id: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
+	const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
+	// struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
 /* @internal */
-export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
+export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
+	const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
 	return nativeResponseValue;
 }
-	// void BlindedPath_free(struct LDKBlindedPath this_obj);
+	// struct LDKEvent Event_htlcintercepted(struct LDKThirtyTwoBytes intercept_id, uint64_t requested_next_hop_scid, struct LDKThirtyTwoBytes payment_hash, uint64_t inbound_amount_msat, uint64_t expected_outbound_amount_msat);
 /* @internal */
-export function BlindedPath_free(this_obj: bigint): void {
+export function Event_htlcintercepted(intercept_id: number, requested_next_hop_scid: bigint, payment_hash: number, inbound_amount_msat: bigint, expected_outbound_amount_msat: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BlindedPath_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Event_htlcintercepted(intercept_id, requested_next_hop_scid, payment_hash, inbound_amount_msat, expected_outbound_amount_msat);
+	return nativeResponseValue;
 }
-	// uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg);
+	// struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
 /* @internal */
-export function BlindedPath_clone_ptr(arg: bigint): bigint {
+export function Event_spendable_outputs(outputs: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BlindedPath_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
 	return nativeResponseValue;
 }
-	// struct LDKBlindedPath BlindedPath_clone(const struct LDKBlindedPath *NONNULL_PTR orig);
+	// struct LDKEvent Event_payment_forwarded(struct LDKThirtyTwoBytes prev_channel_id, struct LDKThirtyTwoBytes next_channel_id, struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx, struct LDKCOption_u64Z outbound_amount_forwarded_msat);
 /* @internal */
-export function BlindedPath_clone(orig: bigint): bigint {
+export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: bigint, claim_from_onchain_tx: boolean, outbound_amount_forwarded_msat: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BlindedPath_clone(orig);
+	const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx, outbound_amount_forwarded_msat);
 	return nativeResponseValue;
 }
-	// void BlindedHop_free(struct LDKBlindedHop this_obj);
+	// struct LDKEvent Event_channel_pending(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKThirtyTwoBytes former_temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKOutPoint funding_txo);
 /* @internal */
-export function BlindedHop_free(this_obj: bigint): void {
+export function Event_channel_pending(channel_id: number, user_channel_id: number, former_temporary_channel_id: number, counterparty_node_id: number, funding_txo: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Event_channel_pending(channel_id, user_channel_id, former_temporary_channel_id, counterparty_node_id, funding_txo);
+	return nativeResponseValue;
 }
-	// uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg);
+	// struct LDKEvent Event_channel_ready(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKChannelTypeFeatures channel_type);
 /* @internal */
-export function BlindedHop_clone_ptr(arg: bigint): bigint {
+export function Event_channel_ready(channel_id: number, user_channel_id: number, counterparty_node_id: number, channel_type: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BlindedHop_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_Event_channel_ready(channel_id, user_channel_id, counterparty_node_id, channel_type);
 	return nativeResponseValue;
 }
-	// struct LDKBlindedHop BlindedHop_clone(const struct LDKBlindedHop *NONNULL_PTR orig);
+	// struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKClosureReason reason);
 /* @internal */
-export function BlindedHop_clone(orig: bigint): bigint {
+export function Event_channel_closed(channel_id: number, user_channel_id: number, reason: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BlindedHop_clone(orig);
+	const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_new(struct LDKCVec_PublicKeyZ node_pks, const struct LDKEntropySource *NONNULL_PTR entropy_source);
+	// struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
 /* @internal */
-export function BlindedPath_new(node_pks: number, entropy_source: bigint): bigint {
+export function Event_discard_funding(channel_id: number, transaction: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BlindedPath_new(node_pks, entropy_source);
+	const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z BlindedPath_write(const struct LDKBlindedPath *NONNULL_PTR obj);
+	// struct LDKEvent Event_open_channel_request(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t funding_satoshis, uint64_t push_msat, struct LDKChannelTypeFeatures channel_type);
 /* @internal */
-export function BlindedPath_write(obj: bigint): number {
+export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BlindedPath_write(obj);
+	const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_BlindedPathDecodeErrorZ BlindedPath_read(struct LDKu8slice ser);
+	// struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
 /* @internal */
-export function BlindedPath_read(ser: number): bigint {
+export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BlindedPath_read(ser);
+	const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
 	return nativeResponseValue;
 }
-	// struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
+	// bool Event_eq(const struct LDKEvent *NONNULL_PTR a, const struct LDKEvent *NONNULL_PTR b);
 /* @internal */
-export function BlindedHop_write(obj: bigint): number {
+export function Event_eq(a: bigint, b: bigint): boolean {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
+	const nativeResponseValue = wasm.TS_Event_eq(a, b);
 	return nativeResponseValue;
 }
-	// struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
+	// struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
 /* @internal */
-export function BlindedHop_read(ser: number): bigint {
+export function Event_write(obj: bigint): number {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
+	const nativeResponseValue = wasm.TS_Event_write(obj);
 	return nativeResponseValue;
 }
-	// void OnionMessenger_free(struct LDKOnionMessenger this_obj);
+	// struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
 /* @internal */
-export function OnionMessenger_free(this_obj: bigint): void {
+export function Event_read(ser: number): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_Event_read(ser);
+	return nativeResponseValue;
 }
-	// void Destination_free(struct LDKDestination this_ptr);
+	// void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
 /* @internal */
-export function Destination_free(this_ptr: bigint): void {
+export function MessageSendEvent_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
 	// debug statements here
 }
-	// uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg);
+	// uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
 /* @internal */
-export function Destination_clone_ptr(arg: bigint): bigint {
+export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Destination_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
 	return nativeResponseValue;
 }
-	// struct LDKDestination Destination_clone(const struct LDKDestination *NONNULL_PTR orig);
+	// struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
 /* @internal */
-export function Destination_clone(orig: bigint): bigint {
+export function MessageSendEvent_clone(orig: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Destination_clone(orig);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKDestination Destination_node(struct LDKPublicKey a);
+	// struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
 /* @internal */
-export function Destination_node(a: number): bigint {
+export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Destination_node(a);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKDestination Destination_blinded_path(struct LDKBlindedPath a);
+	// struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
 /* @internal */
-export function Destination_blinded_path(a: bigint): bigint {
+export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_Destination_blinded_path(a);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
 	return nativeResponseValue;
 }
-	// void SendError_free(struct LDKSendError this_ptr);
-/* @internal */
-export function SendError_free(this_ptr: bigint): void {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
-	// debug statements here
-}
-	// uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
+	// struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
 /* @internal */
-export function SendError_clone_ptr(arg: bigint): bigint {
+export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
+	// struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
 /* @internal */
-export function SendError_clone(orig: bigint): bigint {
+export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_SendError_clone(orig);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
+	// struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
 /* @internal */
-export function SendError_secp256k1(a: Secp256k1Error): bigint {
+export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKSendError SendError_too_big_packet(void);
+	// struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
 /* @internal */
-export function SendError_too_big_packet(): bigint {
+export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_SendError_too_big_packet();
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKSendError SendError_too_few_blinded_hops(void);
+	// struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
 /* @internal */
-export function SendError_too_few_blinded_hops(): bigint {
+export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
+	const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
 	return nativeResponseValue;
 }
-	// struct LDKSendError SendError_invalid_first_hop(void);
+	// struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
 /* @internal */
-export function SendError_invalid_first_hop(): bigint {
+export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_SendError_invalid_first_hop();
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKSendError SendError_invalid_message(void);
+	// struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
 /* @internal */
-export function SendError_invalid_message(): bigint {
+export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_SendError_invalid_message();
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKSendError SendError_buffer_full(void);
+	// struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
 /* @internal */
-export function SendError_buffer_full(): bigint {
+export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_SendError_buffer_full();
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKSendError SendError_get_node_id_failed(void);
+	// struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
 /* @internal */
-export function SendError_get_node_id_failed(): bigint {
+export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_SendError_get_node_id_failed();
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKSendError SendError_blinded_path_advance_failed(void);
+	// struct LDKMessageSendEvent MessageSendEvent_send_channel_announcement(struct LDKPublicKey node_id, struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
 /* @internal */
-export function SendError_blinded_path_advance_failed(): bigint {
+export function MessageSendEvent_send_channel_announcement(node_id: number, msg: bigint, update_msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_SendError_blinded_path_advance_failed();
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_announcement(node_id, msg, update_msg);
 	return nativeResponseValue;
 }
-	// bool SendError_eq(const struct LDKSendError *NONNULL_PTR a, const struct LDKSendError *NONNULL_PTR b);
+	// struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
 /* @internal */
-export function SendError_eq(a: bigint, b: bigint): boolean {
+export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_SendError_eq(a, b);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
 	return nativeResponseValue;
 }
-	// void CustomOnionMessageHandler_free(struct LDKCustomOnionMessageHandler this_ptr);
+	// struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
 /* @internal */
-export function CustomOnionMessageHandler_free(this_ptr: bigint): void {
+export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
+	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKOnionMessenger OnionMessenger_new(struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, struct LDKCustomOnionMessageHandler custom_handler);
+	// struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
 /* @internal */
-export function OnionMessenger_new(entropy_source: bigint, node_signer: bigint, logger: bigint, custom_handler: bigint): bigint {
+export function MessageSendEvent_broadcast_node_announcement(msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_OnionMessenger_new(entropy_source, node_signer, logger, custom_handler);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
 	return nativeResponseValue;
 }
-	// MUST_USE_RES struct LDKCResult_NoneSendErrorZ OnionMessenger_send_onion_message(const struct LDKOnionMessenger *NONNULL_PTR this_arg, struct LDKCVec_PublicKeyZ intermediate_nodes, struct LDKDestination destination, struct LDKOnionMessageContents message, struct LDKBlindedPath reply_path);
+	// struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
 /* @internal */
-export function OnionMessenger_send_onion_message(this_arg: bigint, intermediate_nodes: number, destination: bigint, message: bigint, reply_path: bigint): bigint {
+export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_OnionMessenger_send_onion_message(this_arg, intermediate_nodes, destination, message, reply_path);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
+	// struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
 /* @internal */
-export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
+export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
 	return nativeResponseValue;
 }
-	// struct LDKOnionMessageProvider OnionMessenger_as_OnionMessageProvider(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
+	// struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
 /* @internal */
-export function OnionMessenger_as_OnionMessageProvider(this_arg: bigint): bigint {
+export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageProvider(this_arg);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
 	return nativeResponseValue;
 }
-	// void OnionMessageContents_free(struct LDKOnionMessageContents this_ptr);
+	// struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
 /* @internal */
-export function OnionMessageContents_free(this_ptr: bigint): void {
+export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_OnionMessageContents_free(this_ptr);
-	// debug statements here
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
+	return nativeResponseValue;
 }
-	// uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg);
+	// struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
 /* @internal */
-export function OnionMessageContents_clone_ptr(arg: bigint): bigint {
+export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_OnionMessageContents_clone_ptr(arg);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKOnionMessageContents OnionMessageContents_clone(const struct LDKOnionMessageContents *NONNULL_PTR orig);
+	// struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
 /* @internal */
-export function OnionMessageContents_clone(orig: bigint): bigint {
+export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_OnionMessageContents_clone(orig);
+	const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
 	return nativeResponseValue;
 }
-	// struct LDKOnionMessageContents OnionMessageContents_custom(struct LDKCustomOnionMessageContents a);
+	// void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
 /* @internal */
-export function OnionMessageContents_custom(a: bigint): bigint {
+export function MessageSendEventsProvider_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_OnionMessageContents_custom(a);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
+	// debug statements here
 }
-	// uint64_t CustomOnionMessageContents_clone_ptr(LDKCustomOnionMessageContents *NONNULL_PTR arg);
+	// void OnionMessageProvider_free(struct LDKOnionMessageProvider this_ptr);
 /* @internal */
-export function CustomOnionMessageContents_clone_ptr(arg: bigint): bigint {
+export function OnionMessageProvider_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone_ptr(arg);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_OnionMessageProvider_free(this_ptr);
+	// debug statements here
 }
-	// struct LDKCustomOnionMessageContents CustomOnionMessageContents_clone(const struct LDKCustomOnionMessageContents *NONNULL_PTR orig);
+	// void EventsProvider_free(struct LDKEventsProvider this_ptr);
 /* @internal */
-export function CustomOnionMessageContents_clone(orig: bigint): bigint {
+export function EventsProvider_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone(orig);
-	return nativeResponseValue;
+	const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
+	// debug statements here
 }
-	// void CustomOnionMessageContents_free(struct LDKCustomOnionMessageContents this_ptr);
+	// void EventHandler_free(struct LDKEventHandler this_ptr);
 /* @internal */
-export function CustomOnionMessageContents_free(this_ptr: bigint): void {
+export function EventHandler_free(this_ptr: bigint): void {
 	if(!isWasmInitialized) {
 		throw new Error("initializeWasm() must be awaited first!");
 	}
-	const nativeResponseValue = wasm.TS_CustomOnionMessageContents_free(this_ptr);
+	const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
 	// debug statements here
 }
 	// void GossipSync_free(struct LDKGossipSync this_ptr);
@@ -36952,15 +39216,6 @@ export function RapidGossipSync_new(network_graph: bigint, logger: bigint): bigi
 	}
 	const nativeResponseValue = wasm.TS_RapidGossipSync_new(network_graph, logger);
 	return nativeResponseValue;
-}
-	// MUST_USE_RES struct LDKCResult_u32GraphSyncErrorZ RapidGossipSync_update_network_graph(const struct LDKRapidGossipSync *NONNULL_PTR this_arg, struct LDKu8slice update_data);
-/* @internal */
-export function RapidGossipSync_update_network_graph(this_arg: bigint, update_data: number): bigint {
-	if(!isWasmInitialized) {
-		throw new Error("initializeWasm() must be awaited first!");
-	}
-	const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph(this_arg, update_data);
-	return nativeResponseValue;
 }
 	// MUST_USE_RES struct LDKCResult_u32GraphSyncErrorZ RapidGossipSync_update_network_graph_no_std(const struct LDKRapidGossipSync *NONNULL_PTR this_arg, struct LDKu8slice update_data, struct LDKCOption_u64Z current_time_unix);
 /* @internal */
@@ -37726,6 +39981,15 @@ export function Sha256_eq(a: bigint, b: bigint): boolean {
 	}
 	const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
 	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKSha256 Sha256_from_bytes(const uint8_t (*bytes)[32]);
+/* @internal */
+export function Sha256_from_bytes(bytes: number): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Sha256_from_bytes(bytes);
+	return nativeResponseValue;
 }
 	// void Description_free(struct LDKDescription this_obj);
 /* @internal */
@@ -37988,7 +40252,7 @@ export function Fallback_clone(orig: bigint): bigint {
 	const nativeResponseValue = wasm.TS_Fallback_clone(orig);
 	return nativeResponseValue;
 }
-	// struct LDKFallback Fallback_seg_wit_program(struct LDKU5 version, struct LDKCVec_u8Z program);
+	// struct LDKFallback Fallback_seg_wit_program(struct LDKWitnessVersion version, struct LDKCVec_u8Z program);
 /* @internal */
 export function Fallback_seg_wit_program(version: number, program: number): bigint {
 	if(!isWasmInitialized) {
@@ -38248,6 +40512,15 @@ export function RawInvoice_payment_secret(this_arg: bigint): number {
 	}
 	const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
 	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKCOption_CVec_u8ZZ RawInvoice_payment_metadata(const struct LDKRawInvoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawInvoice_payment_metadata(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_RawInvoice_payment_metadata(this_arg);
+	return nativeResponseValue;
 }
 	// MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
 /* @internal */
@@ -38320,6 +40593,15 @@ export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): big
 	}
 	const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
 	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKThirtyTwoBytes Invoice_signable_hash(const struct LDKInvoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Invoice_signable_hash(this_arg: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Invoice_signable_hash(this_arg);
+	return nativeResponseValue;
 }
 	// MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
 /* @internal */
@@ -38383,6 +40665,15 @@ export function Invoice_payment_secret(this_arg: bigint): number {
 	}
 	const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
 	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKCOption_CVec_u8ZZ Invoice_payment_metadata(const struct LDKInvoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Invoice_payment_metadata(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Invoice_payment_metadata(this_arg);
+	return nativeResponseValue;
 }
 	// MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
 /* @internal */
@@ -38401,6 +40692,15 @@ export function Invoice_recover_payee_pub_key(this_arg: bigint): number {
 	}
 	const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
 	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKCOption_DurationZ Invoice_expires_at(const struct LDKInvoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Invoice_expires_at(this_arg: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Invoice_expires_at(this_arg);
+	return nativeResponseValue;
 }
 	// MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
 /* @internal */
@@ -38410,6 +40710,15 @@ export function Invoice_expiry_time(this_arg: bigint): bigint {
 	}
 	const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
 	return nativeResponseValue;
+}
+	// MUST_USE_RES uint64_t Invoice_expiration_remaining_from_epoch(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t time);
+/* @internal */
+export function Invoice_expiration_remaining_from_epoch(this_arg: bigint, time: bigint): bigint {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Invoice_expiration_remaining_from_epoch(this_arg, time);
+	return nativeResponseValue;
 }
 	// MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
 /* @internal */
@@ -38428,6 +40737,15 @@ export function Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
 	}
 	const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry_delta(this_arg);
 	return nativeResponseValue;
+}
+	// MUST_USE_RES struct LDKCVec_AddressZ Invoice_fallback_addresses(const struct LDKInvoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Invoice_fallback_addresses(this_arg: bigint): number {
+	if(!isWasmInitialized) {
+		throw new Error("initializeWasm() must be awaited first!");
+	}
+	const nativeResponseValue = wasm.TS_Invoice_fallback_addresses(this_arg);
+	return nativeResponseValue;
 }
 	// MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
 /* @internal */
@@ -39062,66 +41380,66 @@ js_invoke = function(obj_ptr: number, fn_id: number, arg1: bigint|number, arg2:
 		case 39: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
 		case 40: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
 		case 41: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
-		case 42: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
-		case 43: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
-		case 44: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
-		case 45: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
-		case 46: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
-		case 47: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
-		case 48: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
-		case 49: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
-		case 50: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
-		case 51: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
-		case 52: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
-		case 53: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
-		case 54: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
-		case 55: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
-		case 56: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
-		case 57: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
-		case 58: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
-		case 59: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
-		case 60: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
-		case 61: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
-		case 62: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
-		case 63: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
-		case 64: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
-		case 65: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
-		case 66: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
-		case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
-		case 68: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
-		case 69: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
-		case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
-		case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
-		case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
-		case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
-		case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
-		case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
-		case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
-		case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
-		case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
-		case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
-		case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
-		case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
-		case 82: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
-		case 83: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
-		case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
-		case 85: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
-		case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
-		case 87: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
-		case 88: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
-		case 89: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
-		case 90: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
-		case 91: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
-		case 92: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
-		case 93: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
-		case 94: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
-		case 95: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
-		case 96: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
-		case 97: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
-		case 98: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
-		case 99: fn = Object.getOwnPropertyDescriptor(obj, "processing_queue_high"); break;
-		case 100: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
-		case 101: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
+		case 42: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
+		case 43: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
+		case 44: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
+		case 45: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
+		case 46: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
+		case 47: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
+		case 48: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
+		case 49: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
+		case 50: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
+		case 51: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
+		case 52: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
+		case 53: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
+		case 54: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
+		case 55: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
+		case 56: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
+		case 57: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
+		case 58: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
+		case 59: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
+		case 60: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
+		case 61: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
+		case 62: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
+		case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
+		case 64: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
+		case 65: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
+		case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
+		case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
+		case 68: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
+		case 69: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
+		case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
+		case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
+		case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
+		case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
+		case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
+		case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
+		case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
+		case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
+		case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
+		case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
+		case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
+		case 81: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
+		case 82: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
+		case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
+		case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
+		case 85: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
+		case 86: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
+		case 87: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
+		case 88: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
+		case 89: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
+		case 90: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
+		case 91: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
+		case 92: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
+		case 93: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
+		case 94: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
+		case 95: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
+		case 96: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
+		case 97: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
+		case 98: fn = Object.getOwnPropertyDescriptor(obj, "processing_queue_high"); break;
+		case 99: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
+		case 100: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
+		case 101: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
 		case 102: fn = Object.getOwnPropertyDescriptor(obj, "handle_onion_message"); break;
 		case 103: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
 		case 104: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
@@ -39144,7 +41462,14 @@ js_invoke = function(obj_ptr: number, fn_id: number, arg1: bigint|number, arg2:
 		console.error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
 		throw new Error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
 	}
-	const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+	var ret;
+	try {
+		ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+	} catch (e) {
+		console.error("Got an exception calling function with id " + fn_id + "! This is fatal.");
+		console.error(e);
+		throw e;
+	}
 	if (ret === undefined || ret === null) return BigInt(0);
 	return BigInt(ret);
 }
\ No newline at end of file