+ const nativeResponseValue = wasm.TS_Type_free(this_ptr);
+ // debug statements here
+}
+ // void OfferId_free(struct LDKOfferId this_obj);
+/* @internal */
+export function OfferId_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferId_free(this_obj);
+ // debug statements here
+}
+ // const uint8_t (*OfferId_get_a(const struct LDKOfferId *NONNULL_PTR this_ptr))[32];
+/* @internal */
+export function OfferId_get_a(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferId_get_a(this_ptr);
+ return nativeResponseValue;
+}
+ // void OfferId_set_a(struct LDKOfferId *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+/* @internal */
+export function OfferId_set_a(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferId_set_a(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKOfferId OfferId_new(struct LDKThirtyTwoBytes a_arg);
+/* @internal */
+export function OfferId_new(a_arg: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferId_new(a_arg);
+ return nativeResponseValue;
+}
+ // uint64_t OfferId_clone_ptr(LDKOfferId *NONNULL_PTR arg);
+/* @internal */
+export function OfferId_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferId_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKOfferId OfferId_clone(const struct LDKOfferId *NONNULL_PTR orig);
+/* @internal */
+export function OfferId_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferId_clone(orig);
+ return nativeResponseValue;
+}
+ // bool OfferId_eq(const struct LDKOfferId *NONNULL_PTR a, const struct LDKOfferId *NONNULL_PTR b);
+/* @internal */
+export function OfferId_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferId_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z OfferId_write(const struct LDKOfferId *NONNULL_PTR obj);
+/* @internal */
+export function OfferId_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferId_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OfferIdDecodeErrorZ OfferId_read(struct LDKu8slice ser);
+/* @internal */
+export function OfferId_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferId_read(ser);
+ return nativeResponseValue;
+}
+ // void OfferWithExplicitMetadataBuilder_free(struct LDKOfferWithExplicitMetadataBuilder this_obj);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_free(this_obj);
+ // debug statements here
+}
+ // uint64_t OfferWithExplicitMetadataBuilder_clone_ptr(LDKOfferWithExplicitMetadataBuilder *NONNULL_PTR arg);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKOfferWithExplicitMetadataBuilder OfferWithExplicitMetadataBuilder_clone(const struct LDKOfferWithExplicitMetadataBuilder *NONNULL_PTR orig);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_clone(orig);
+ return nativeResponseValue;
+}
+ // void OfferWithDerivedMetadataBuilder_free(struct LDKOfferWithDerivedMetadataBuilder this_obj);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_free(this_obj);
+ // debug statements here
+}
+ // uint64_t OfferWithDerivedMetadataBuilder_clone_ptr(LDKOfferWithDerivedMetadataBuilder *NONNULL_PTR arg);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKOfferWithDerivedMetadataBuilder OfferWithDerivedMetadataBuilder_clone(const struct LDKOfferWithDerivedMetadataBuilder *NONNULL_PTR orig);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_clone(orig);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKOfferWithExplicitMetadataBuilder OfferWithExplicitMetadataBuilder_new(struct LDKPublicKey signing_pubkey);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_new(signing_pubkey: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_new(signing_pubkey);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ OfferWithExplicitMetadataBuilder_metadata(struct LDKOfferWithExplicitMetadataBuilder this_arg, struct LDKCVec_u8Z metadata);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_metadata(this_arg: bigint, metadata: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_metadata(this_arg, metadata);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES void OfferWithExplicitMetadataBuilder_chain(struct LDKOfferWithExplicitMetadataBuilder this_arg, enum LDKNetwork network);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_chain(this_arg: bigint, network: Network): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_chain(this_arg, network);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithExplicitMetadataBuilder_amount_msats(struct LDKOfferWithExplicitMetadataBuilder this_arg, uint64_t amount_msats);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_amount_msats(this_arg: bigint, amount_msats: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_amount_msats(this_arg, amount_msats);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithExplicitMetadataBuilder_absolute_expiry(struct LDKOfferWithExplicitMetadataBuilder this_arg, uint64_t absolute_expiry);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_absolute_expiry(this_arg: bigint, absolute_expiry: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_absolute_expiry(this_arg, absolute_expiry);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithExplicitMetadataBuilder_description(struct LDKOfferWithExplicitMetadataBuilder this_arg, struct LDKStr description);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_description(this_arg: bigint, description: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_description(this_arg, description);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithExplicitMetadataBuilder_issuer(struct LDKOfferWithExplicitMetadataBuilder this_arg, struct LDKStr issuer);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_issuer(this_arg: bigint, issuer: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_issuer(this_arg, issuer);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithExplicitMetadataBuilder_path(struct LDKOfferWithExplicitMetadataBuilder this_arg, struct LDKBlindedMessagePath path);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_path(this_arg: bigint, path: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_path(this_arg, path);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithExplicitMetadataBuilder_supported_quantity(struct LDKOfferWithExplicitMetadataBuilder this_arg, struct LDKQuantity quantity);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_supported_quantity(this_arg: bigint, quantity: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_supported_quantity(this_arg, quantity);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKCResult_OfferBolt12SemanticErrorZ OfferWithExplicitMetadataBuilder_build(struct LDKOfferWithExplicitMetadataBuilder this_arg);
+/* @internal */
+export function OfferWithExplicitMetadataBuilder_build(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithExplicitMetadataBuilder_build(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKOfferWithDerivedMetadataBuilder OfferWithDerivedMetadataBuilder_deriving_signing_pubkey(struct LDKPublicKey node_id, const struct LDKExpandedKey *NONNULL_PTR expanded_key, struct LDKNonce nonce);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_deriving_signing_pubkey(node_id: number, expanded_key: bigint, nonce: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_deriving_signing_pubkey(node_id, expanded_key, nonce);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES void OfferWithDerivedMetadataBuilder_chain(struct LDKOfferWithDerivedMetadataBuilder this_arg, enum LDKNetwork network);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_chain(this_arg: bigint, network: Network): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_chain(this_arg, network);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithDerivedMetadataBuilder_amount_msats(struct LDKOfferWithDerivedMetadataBuilder this_arg, uint64_t amount_msats);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_amount_msats(this_arg: bigint, amount_msats: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_amount_msats(this_arg, amount_msats);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithDerivedMetadataBuilder_absolute_expiry(struct LDKOfferWithDerivedMetadataBuilder this_arg, uint64_t absolute_expiry);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_absolute_expiry(this_arg: bigint, absolute_expiry: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_absolute_expiry(this_arg, absolute_expiry);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithDerivedMetadataBuilder_description(struct LDKOfferWithDerivedMetadataBuilder this_arg, struct LDKStr description);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_description(this_arg: bigint, description: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_description(this_arg, description);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithDerivedMetadataBuilder_issuer(struct LDKOfferWithDerivedMetadataBuilder this_arg, struct LDKStr issuer);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_issuer(this_arg: bigint, issuer: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_issuer(this_arg, issuer);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithDerivedMetadataBuilder_path(struct LDKOfferWithDerivedMetadataBuilder this_arg, struct LDKBlindedMessagePath path);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_path(this_arg: bigint, path: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_path(this_arg, path);
+ // debug statements here
+}
+ // MUST_USE_RES void OfferWithDerivedMetadataBuilder_supported_quantity(struct LDKOfferWithDerivedMetadataBuilder this_arg, struct LDKQuantity quantity);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_supported_quantity(this_arg: bigint, quantity: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_supported_quantity(this_arg, quantity);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKCResult_OfferBolt12SemanticErrorZ OfferWithDerivedMetadataBuilder_build(struct LDKOfferWithDerivedMetadataBuilder this_arg);
+/* @internal */
+export function OfferWithDerivedMetadataBuilder_build(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OfferWithDerivedMetadataBuilder_build(this_arg);
+ return nativeResponseValue;
+}
+ // void Offer_free(struct LDKOffer this_obj);
+/* @internal */
+export function Offer_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_free(this_obj);
+ // debug statements here
+}
+ // uint64_t Offer_clone_ptr(LDKOffer *NONNULL_PTR arg);
+/* @internal */
+export function Offer_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKOffer Offer_clone(const struct LDKOffer *NONNULL_PTR orig);
+/* @internal */
+export function Offer_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_clone(orig);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ Offer_chains(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_chains(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_chains(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Offer_metadata(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_metadata(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_AmountZ Offer_amount(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_amount(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_amount(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString Offer_description(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_description(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_description(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKOfferFeatures Offer_offer_features(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_offer_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_offer_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z Offer_absolute_expiry(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_absolute_expiry(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_absolute_expiry(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString Offer_issuer(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_issuer(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_issuer(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_BlindedMessagePathZ Offer_paths(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_paths(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_paths(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKQuantity Offer_supported_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_supported_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_supported_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey Offer_signing_pubkey(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_signing_pubkey(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_signing_pubkey(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKOfferId Offer_id(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_id(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_id(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES bool Offer_supports_chain(const struct LDKOffer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes chain);
+/* @internal */
+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_Offer_supports_chain(this_arg, chain);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES bool Offer_is_expired_no_std(const struct LDKOffer *NONNULL_PTR this_arg, uint64_t duration_since_epoch);
+/* @internal */
+export function Offer_is_expired_no_std(this_arg: bigint, duration_since_epoch: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_is_expired_no_std(this_arg, duration_since_epoch);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES bool Offer_is_valid_quantity(const struct LDKOffer *NONNULL_PTR this_arg, uint64_t quantity);
+/* @internal */
+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_Offer_is_valid_quantity(this_arg, quantity);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES bool Offer_expects_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
+/* @internal */
+export function Offer_expects_quantity(this_arg: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_expects_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ Offer_request_invoice_deriving_payer_id(const struct LDKOffer *NONNULL_PTR this_arg, const struct LDKExpandedKey *NONNULL_PTR expanded_key, struct LDKNonce nonce, struct LDKThirtyTwoBytes payment_id);
+/* @internal */
+export function Offer_request_invoice_deriving_payer_id(this_arg: bigint, expanded_key: bigint, nonce: bigint, payment_id: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_request_invoice_deriving_payer_id(this_arg, expanded_key, nonce, payment_id);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ Offer_request_invoice_deriving_metadata(const struct LDKOffer *NONNULL_PTR this_arg, struct LDKPublicKey payer_id, const struct LDKExpandedKey *NONNULL_PTR expanded_key, struct LDKNonce nonce, struct LDKThirtyTwoBytes payment_id);
+/* @internal */
+export function Offer_request_invoice_deriving_metadata(this_arg: bigint, payer_id: number, expanded_key: bigint, nonce: bigint, payment_id: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_request_invoice_deriving_metadata(this_arg, payer_id, expanded_key, nonce, payment_id);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ Offer_request_invoice(const struct LDKOffer *NONNULL_PTR this_arg, struct LDKCVec_u8Z metadata, struct LDKPublicKey payer_id);
+/* @internal */
+export function Offer_request_invoice(this_arg: bigint, metadata: number, payer_id: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_request_invoice(this_arg, metadata, payer_id);
+ return nativeResponseValue;
+}
+ // uint64_t Offer_hash(const struct LDKOffer *NONNULL_PTR o);
+/* @internal */
+export function Offer_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_hash(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OfferDecodeErrorZ Offer_read(struct LDKu8slice ser);
+/* @internal */
+export function Offer_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_read(ser);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z Offer_write(const struct LDKOffer *NONNULL_PTR obj);
+/* @internal */
+export function Offer_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_write(obj);
+ return nativeResponseValue;
+}
+ // void Amount_free(struct LDKAmount this_ptr);
+/* @internal */
+export function Amount_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Amount_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t Amount_clone_ptr(LDKAmount *NONNULL_PTR arg);
+/* @internal */
+export function Amount_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Amount_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKAmount Amount_clone(const struct LDKAmount *NONNULL_PTR orig);
+/* @internal */
+export function Amount_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Amount_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKAmount Amount_bitcoin(uint64_t amount_msats);
+/* @internal */
+export function Amount_bitcoin(amount_msats: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Amount_bitcoin(amount_msats);
+ return nativeResponseValue;
+}
+ // struct LDKAmount Amount_currency(struct LDKThreeBytes iso4217_code, uint64_t amount);
+/* @internal */
+export function Amount_currency(iso4217_code: number, amount: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Amount_currency(iso4217_code, amount);
+ return nativeResponseValue;
+}
+ // void Quantity_free(struct LDKQuantity this_ptr);
+/* @internal */
+export function Quantity_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Quantity_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t Quantity_clone_ptr(LDKQuantity *NONNULL_PTR arg);
+/* @internal */
+export function Quantity_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Quantity_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKQuantity Quantity_clone(const struct LDKQuantity *NONNULL_PTR orig);
+/* @internal */
+export function Quantity_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Quantity_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKQuantity Quantity_bounded(uint64_t a);
+/* @internal */
+export function Quantity_bounded(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Quantity_bounded(a);
+ return nativeResponseValue;
+}
+ // struct LDKQuantity Quantity_unbounded(void);
+/* @internal */
+export function Quantity_unbounded(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Quantity_unbounded();
+ return nativeResponseValue;
+}
+ // struct LDKQuantity Quantity_one(void);
+/* @internal */
+export function Quantity_one(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Quantity_one();
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OfferBolt12ParseErrorZ Offer_from_str(struct LDKStr s);
+/* @internal */
+export function Offer_from_str(s: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_from_str(s);
+ return nativeResponseValue;
+}
+ // struct LDKStr Offer_to_str(const struct LDKOffer *NONNULL_PTR o);
+/* @internal */
+export function Offer_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_to_str(o);
+ return nativeResponseValue;
+}
+ // void InvoiceWithExplicitSigningPubkeyBuilder_free(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_obj);
+/* @internal */
+export function InvoiceWithExplicitSigningPubkeyBuilder_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_free(this_obj);
+ // debug statements here
+}
+ // void InvoiceWithDerivedSigningPubkeyBuilder_free(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_obj);
+/* @internal */
+export function InvoiceWithDerivedSigningPubkeyBuilder_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_free(this_obj);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ InvoiceWithExplicitSigningPubkeyBuilder_build(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg);
+/* @internal */
+export function InvoiceWithExplicitSigningPubkeyBuilder_build(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_build(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES void InvoiceWithExplicitSigningPubkeyBuilder_relative_expiry(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg, uint32_t relative_expiry_secs);
+/* @internal */
+export function InvoiceWithExplicitSigningPubkeyBuilder_relative_expiry(this_arg: bigint, relative_expiry_secs: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_relative_expiry(this_arg, relative_expiry_secs);
+ // debug statements here
+}
+ // MUST_USE_RES void InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wsh(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg, const uint8_t (*script_hash)[32]);
+/* @internal */
+export function InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wsh(this_arg: bigint, script_hash: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wsh(this_arg, script_hash);
+ // debug statements here
+}
+ // MUST_USE_RES void InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wpkh(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg, const uint8_t (*pubkey_hash)[20]);
+/* @internal */
+export function InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wpkh(this_arg: bigint, pubkey_hash: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_fallback_v0_p2wpkh(this_arg, pubkey_hash);
+ // debug statements here
+}
+ // MUST_USE_RES void InvoiceWithExplicitSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg, struct LDKTweakedPublicKey output_key);
+/* @internal */
+export function InvoiceWithExplicitSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(this_arg: bigint, utput_key: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(this_arg, utput_key);
+ // debug statements here
+}
+ // MUST_USE_RES void InvoiceWithExplicitSigningPubkeyBuilder_allow_mpp(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_arg);
+/* @internal */
+export function InvoiceWithExplicitSigningPubkeyBuilder_allow_mpp(this_arg: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithExplicitSigningPubkeyBuilder_allow_mpp(this_arg);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ InvoiceWithDerivedSigningPubkeyBuilder_build_and_sign(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg);
+/* @internal */
+export function InvoiceWithDerivedSigningPubkeyBuilder_build_and_sign(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_build_and_sign(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES void InvoiceWithDerivedSigningPubkeyBuilder_relative_expiry(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg, uint32_t relative_expiry_secs);
+/* @internal */
+export function InvoiceWithDerivedSigningPubkeyBuilder_relative_expiry(this_arg: bigint, relative_expiry_secs: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_relative_expiry(this_arg, relative_expiry_secs);
+ // debug statements here
+}
+ // MUST_USE_RES void InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wsh(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg, const uint8_t (*script_hash)[32]);
+/* @internal */
+export function InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wsh(this_arg: bigint, script_hash: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wsh(this_arg, script_hash);
+ // debug statements here
+}
+ // MUST_USE_RES void InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wpkh(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg, const uint8_t (*pubkey_hash)[20]);
+/* @internal */
+export function InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wpkh(this_arg: bigint, pubkey_hash: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_fallback_v0_p2wpkh(this_arg, pubkey_hash);
+ // debug statements here
+}
+ // MUST_USE_RES void InvoiceWithDerivedSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg, struct LDKTweakedPublicKey output_key);
+/* @internal */
+export function InvoiceWithDerivedSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(this_arg: bigint, utput_key: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_fallback_v1_p2tr_tweaked(this_arg, utput_key);
+ // debug statements here
+}
+ // MUST_USE_RES void InvoiceWithDerivedSigningPubkeyBuilder_allow_mpp(struct LDKInvoiceWithDerivedSigningPubkeyBuilder this_arg);
+/* @internal */
+export function InvoiceWithDerivedSigningPubkeyBuilder_allow_mpp(this_arg: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceWithDerivedSigningPubkeyBuilder_allow_mpp(this_arg);
+ // debug statements here
+}
+ // void UnsignedBolt12Invoice_free(struct LDKUnsignedBolt12Invoice this_obj);
+/* @internal */
+export function UnsignedBolt12Invoice_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_free(this_obj);
+ // debug statements here
+}
+ // uint64_t UnsignedBolt12Invoice_clone_ptr(LDKUnsignedBolt12Invoice *NONNULL_PTR arg);
+/* @internal */
+export function UnsignedBolt12Invoice_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKUnsignedBolt12Invoice UnsignedBolt12Invoice_clone(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR orig);
+/* @internal */
+export function UnsignedBolt12Invoice_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_clone(orig);
+ return nativeResponseValue;
+}
+ // void SignBolt12InvoiceFn_free(struct LDKSignBolt12InvoiceFn this_ptr);
+/* @internal */
+export function SignBolt12InvoiceFn_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignBolt12InvoiceFn_free(this_ptr);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKTaggedHash UnsignedBolt12Invoice_tagged_hash(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_tagged_hash(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_tagged_hash(this_arg);
+ return nativeResponseValue;
+}
+ // void Bolt12Invoice_free(struct LDKBolt12Invoice this_obj);
+/* @internal */
+export function Bolt12Invoice_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_free(this_obj);
+ // debug statements here
+}
+ // uint64_t Bolt12Invoice_clone_ptr(LDKBolt12Invoice *NONNULL_PTR arg);
+/* @internal */
+export function Bolt12Invoice_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKBolt12Invoice Bolt12Invoice_clone(const struct LDKBolt12Invoice *NONNULL_PTR orig);
+/* @internal */
+export function Bolt12Invoice_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_clone(orig);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t UnsignedBolt12Invoice_created_at(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_created_at(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_created_at(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t UnsignedBolt12Invoice_relative_expiry(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_relative_expiry(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_relative_expiry(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_StrZ UnsignedBolt12Invoice_fallbacks(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_fallbacks(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_fallbacks(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKBolt12InvoiceFeatures UnsignedBolt12Invoice_invoice_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_invoice_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_invoice_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey UnsignedBolt12Invoice_signing_pubkey(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_signing_pubkey(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_signing_pubkey(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_CVec_ThirtyTwoBytesZZ UnsignedBolt12Invoice_offer_chains(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_offer_chains(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_offer_chains(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedBolt12Invoice_chain(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_chain(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_chain(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_CVec_u8ZZ UnsignedBolt12Invoice_metadata(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_metadata(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_AmountZ UnsignedBolt12Invoice_amount(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_amount(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_amount(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKOfferFeatures UnsignedBolt12Invoice_offer_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_offer_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_offer_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_description(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_description(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_description(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z UnsignedBolt12Invoice_absolute_expiry(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_absolute_expiry(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_absolute_expiry(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_issuer(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_issuer(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_issuer(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_BlindedMessagePathZ UnsignedBolt12Invoice_message_paths(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_message_paths(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_message_paths(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_QuantityZ UnsignedBolt12Invoice_supported_quantity(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_supported_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_supported_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKu8slice UnsignedBolt12Invoice_payer_metadata(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_payer_metadata(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKInvoiceRequestFeatures UnsignedBolt12Invoice_invoice_request_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_invoice_request_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_invoice_request_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z UnsignedBolt12Invoice_quantity(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey UnsignedBolt12Invoice_payer_id(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_payer_id(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_id(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_payer_note(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_payer_note(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_note(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedBolt12Invoice_payment_hash(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_payment_hash(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payment_hash(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t UnsignedBolt12Invoice_amount_msats(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedBolt12Invoice_amount_msats(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_amount_msats(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t Bolt12Invoice_created_at(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_created_at(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_created_at(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t Bolt12Invoice_relative_expiry(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_relative_expiry(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_relative_expiry(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_StrZ Bolt12Invoice_fallbacks(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_fallbacks(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_fallbacks(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12Invoice_invoice_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_invoice_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_invoice_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey Bolt12Invoice_signing_pubkey(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_signing_pubkey(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_signing_pubkey(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_CVec_ThirtyTwoBytesZZ Bolt12Invoice_offer_chains(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_offer_chains(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_offer_chains(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_chain(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_chain(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_chain(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Bolt12Invoice_metadata(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_metadata(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_AmountZ Bolt12Invoice_amount(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_amount(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_amount(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKOfferFeatures Bolt12Invoice_offer_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_offer_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_offer_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_description(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_description(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_description(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z Bolt12Invoice_absolute_expiry(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_absolute_expiry(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_absolute_expiry(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_issuer(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_issuer(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_issuer(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_BlindedMessagePathZ Bolt12Invoice_message_paths(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_message_paths(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_message_paths(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_QuantityZ Bolt12Invoice_supported_quantity(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_supported_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_supported_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKu8slice Bolt12Invoice_payer_metadata(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_payer_metadata(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKInvoiceRequestFeatures Bolt12Invoice_invoice_request_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_invoice_request_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_invoice_request_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z Bolt12Invoice_quantity(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey Bolt12Invoice_payer_id(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_payer_id(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_id(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_payer_note(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_payer_note(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_note(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_payment_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_payment_hash(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_payment_hash(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t Bolt12Invoice_amount_msats(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_amount_msats(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_amount_msats(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKSchnorrSignature Bolt12Invoice_signature(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_signature(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_signature(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_signable_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt12Invoice_signable_hash(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_signable_hash(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesNoneZ Bolt12Invoice_verify_using_metadata(const struct LDKBolt12Invoice *NONNULL_PTR this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
+/* @internal */
+export function Bolt12Invoice_verify_using_metadata(this_arg: bigint, key: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_verify_using_metadata(this_arg, key);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesNoneZ Bolt12Invoice_verify_using_payer_data(const struct LDKBolt12Invoice *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id, struct LDKNonce nonce, const struct LDKExpandedKey *NONNULL_PTR key);
+/* @internal */
+export function Bolt12Invoice_verify_using_payer_data(this_arg: bigint, payment_id: number, nonce: bigint, key: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_verify_using_payer_data(this_arg, payment_id, nonce, key);
+ return nativeResponseValue;
+}
+ // uint64_t Bolt12Invoice_hash(const struct LDKBolt12Invoice *NONNULL_PTR o);
+/* @internal */
+export function Bolt12Invoice_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_hash(o);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z UnsignedBolt12Invoice_write(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR obj);
+/* @internal */
+export function UnsignedBolt12Invoice_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z Bolt12Invoice_write(const struct LDKBolt12Invoice *NONNULL_PTR obj);
+/* @internal */
+export function Bolt12Invoice_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt12InvoiceDecodeErrorZ Bolt12Invoice_read(struct LDKu8slice ser);
+/* @internal */
+export function Bolt12Invoice_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12Invoice_read(ser);
+ return nativeResponseValue;
+}
+ // void InvoiceError_free(struct LDKInvoiceError this_obj);
+/* @internal */
+export function InvoiceError_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_free(this_obj);
+ // debug statements here
+}
+ // struct LDKErroneousField InvoiceError_get_erroneous_field(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
+/* @internal */
+export function InvoiceError_get_erroneous_field(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_get_erroneous_field(this_ptr);
+ return nativeResponseValue;
+}
+ // void InvoiceError_set_erroneous_field(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKErroneousField val);
+/* @internal */
+export function InvoiceError_set_erroneous_field(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_set_erroneous_field(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKUntrustedString InvoiceError_get_message(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
+/* @internal */
+export function InvoiceError_get_message(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_get_message(this_ptr);
+ return nativeResponseValue;
+}
+ // void InvoiceError_set_message(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKUntrustedString val);
+/* @internal */
+export function InvoiceError_set_message(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_set_message(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKInvoiceError InvoiceError_new(struct LDKErroneousField erroneous_field_arg, struct LDKUntrustedString message_arg);
+/* @internal */
+export function InvoiceError_new(erroneous_field_arg: bigint, message_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_new(erroneous_field_arg, message_arg);
+ return nativeResponseValue;
+}
+ // uint64_t InvoiceError_clone_ptr(LDKInvoiceError *NONNULL_PTR arg);
+/* @internal */
+export function InvoiceError_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKInvoiceError InvoiceError_clone(const struct LDKInvoiceError *NONNULL_PTR orig);
+/* @internal */
+export function InvoiceError_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_clone(orig);
+ return nativeResponseValue;
+}
+ // void ErroneousField_free(struct LDKErroneousField this_obj);
+/* @internal */
+export function ErroneousField_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ErroneousField_free(this_obj);
+ // debug statements here
+}
+ // uint64_t ErroneousField_get_tlv_fieldnum(const struct LDKErroneousField *NONNULL_PTR this_ptr);
+/* @internal */
+export function ErroneousField_get_tlv_fieldnum(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ErroneousField_get_tlv_fieldnum(this_ptr);
+ return nativeResponseValue;
+}
+ // void ErroneousField_set_tlv_fieldnum(struct LDKErroneousField *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ErroneousField_set_tlv_fieldnum(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ErroneousField_set_tlv_fieldnum(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKCOption_CVec_u8ZZ ErroneousField_get_suggested_value(const struct LDKErroneousField *NONNULL_PTR this_ptr);
+/* @internal */
+export function ErroneousField_get_suggested_value(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ErroneousField_get_suggested_value(this_ptr);
+ return nativeResponseValue;
+}
+ // void ErroneousField_set_suggested_value(struct LDKErroneousField *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
+/* @internal */
+export function ErroneousField_set_suggested_value(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ErroneousField_set_suggested_value(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKErroneousField ErroneousField_new(uint64_t tlv_fieldnum_arg, struct LDKCOption_CVec_u8ZZ suggested_value_arg);
+/* @internal */
+export function ErroneousField_new(tlv_fieldnum_arg: bigint, suggested_value_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ErroneousField_new(tlv_fieldnum_arg, suggested_value_arg);
+ return nativeResponseValue;
+}
+ // uint64_t ErroneousField_clone_ptr(LDKErroneousField *NONNULL_PTR arg);
+/* @internal */
+export function ErroneousField_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ErroneousField_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKErroneousField ErroneousField_clone(const struct LDKErroneousField *NONNULL_PTR orig);
+/* @internal */
+export function ErroneousField_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ErroneousField_clone(orig);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKInvoiceError InvoiceError_from_string(struct LDKStr s);
+/* @internal */
+export function InvoiceError_from_string(s: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_from_string(s);
+ return nativeResponseValue;
+}
+ // struct LDKStr InvoiceError_to_str(const struct LDKInvoiceError *NONNULL_PTR o);
+/* @internal */
+export function InvoiceError_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z InvoiceError_write(const struct LDKInvoiceError *NONNULL_PTR obj);
+/* @internal */
+export function InvoiceError_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InvoiceErrorDecodeErrorZ InvoiceError_read(struct LDKu8slice ser);
+/* @internal */
+export function InvoiceError_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_read(ser);
+ return nativeResponseValue;
+}
+ // void InvoiceRequestWithExplicitPayerIdBuilder_free(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_obj);
+/* @internal */
+export function InvoiceRequestWithExplicitPayerIdBuilder_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_free(this_obj);
+ // debug statements here
+}
+ // void InvoiceRequestWithDerivedPayerIdBuilder_free(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_obj);
+/* @internal */
+export function InvoiceRequestWithDerivedPayerIdBuilder_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_free(this_obj);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ InvoiceRequestWithExplicitPayerIdBuilder_build(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_arg);
+/* @internal */
+export function InvoiceRequestWithExplicitPayerIdBuilder_build(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_build(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithExplicitPayerIdBuilder_chain(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_arg, enum LDKNetwork network);
+/* @internal */
+export function InvoiceRequestWithExplicitPayerIdBuilder_chain(this_arg: bigint, network: Network): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_chain(this_arg, network);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithExplicitPayerIdBuilder_amount_msats(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_arg, uint64_t amount_msats);
+/* @internal */
+export function InvoiceRequestWithExplicitPayerIdBuilder_amount_msats(this_arg: bigint, amount_msats: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_amount_msats(this_arg, amount_msats);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithExplicitPayerIdBuilder_quantity(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_arg, uint64_t quantity);
+/* @internal */
+export function InvoiceRequestWithExplicitPayerIdBuilder_quantity(this_arg: bigint, quantity: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_quantity(this_arg, quantity);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES void InvoiceRequestWithExplicitPayerIdBuilder_payer_note(struct LDKInvoiceRequestWithExplicitPayerIdBuilder this_arg, struct LDKStr payer_note);
+/* @internal */
+export function InvoiceRequestWithExplicitPayerIdBuilder_payer_note(this_arg: bigint, payer_note: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithExplicitPayerIdBuilder_payer_note(this_arg, payer_note);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKCResult_InvoiceRequestBolt12SemanticErrorZ InvoiceRequestWithDerivedPayerIdBuilder_build_and_sign(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_arg);
+/* @internal */
+export function InvoiceRequestWithDerivedPayerIdBuilder_build_and_sign(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_build_and_sign(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithDerivedPayerIdBuilder_chain(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_arg, enum LDKNetwork network);
+/* @internal */
+export function InvoiceRequestWithDerivedPayerIdBuilder_chain(this_arg: bigint, network: Network): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_chain(this_arg, network);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithDerivedPayerIdBuilder_amount_msats(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_arg, uint64_t amount_msats);
+/* @internal */
+export function InvoiceRequestWithDerivedPayerIdBuilder_amount_msats(this_arg: bigint, amount_msats: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_amount_msats(this_arg, amount_msats);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ InvoiceRequestWithDerivedPayerIdBuilder_quantity(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_arg, uint64_t quantity);
+/* @internal */
+export function InvoiceRequestWithDerivedPayerIdBuilder_quantity(this_arg: bigint, quantity: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_quantity(this_arg, quantity);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES void InvoiceRequestWithDerivedPayerIdBuilder_payer_note(struct LDKInvoiceRequestWithDerivedPayerIdBuilder this_arg, struct LDKStr payer_note);
+/* @internal */
+export function InvoiceRequestWithDerivedPayerIdBuilder_payer_note(this_arg: bigint, payer_note: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestWithDerivedPayerIdBuilder_payer_note(this_arg, payer_note);
+ // debug statements here
+}
+ // void UnsignedInvoiceRequest_free(struct LDKUnsignedInvoiceRequest this_obj);
+/* @internal */
+export function UnsignedInvoiceRequest_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_free(this_obj);
+ // debug statements here
+}
+ // uint64_t UnsignedInvoiceRequest_clone_ptr(LDKUnsignedInvoiceRequest *NONNULL_PTR arg);
+/* @internal */
+export function UnsignedInvoiceRequest_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKUnsignedInvoiceRequest UnsignedInvoiceRequest_clone(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR orig);
+/* @internal */
+export function UnsignedInvoiceRequest_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_clone(orig);
+ return nativeResponseValue;
+}
+ // void SignInvoiceRequestFn_free(struct LDKSignInvoiceRequestFn this_ptr);
+/* @internal */
+export function SignInvoiceRequestFn_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignInvoiceRequestFn_free(this_ptr);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKTaggedHash UnsignedInvoiceRequest_tagged_hash(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_tagged_hash(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_tagged_hash(this_arg);
+ return nativeResponseValue;
+}
+ // void InvoiceRequest_free(struct LDKInvoiceRequest this_obj);
+/* @internal */
+export function InvoiceRequest_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_free(this_obj);
+ // debug statements here
+}
+ // uint64_t InvoiceRequest_clone_ptr(LDKInvoiceRequest *NONNULL_PTR arg);
+/* @internal */
+export function InvoiceRequest_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKInvoiceRequest InvoiceRequest_clone(const struct LDKInvoiceRequest *NONNULL_PTR orig);
+/* @internal */
+export function InvoiceRequest_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_clone(orig);
+ return nativeResponseValue;
+}
+ // void VerifiedInvoiceRequest_free(struct LDKVerifiedInvoiceRequest this_obj);
+/* @internal */
+export function VerifiedInvoiceRequest_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_free(this_obj);
+ // debug statements here
+}
+ // struct LDKOfferId VerifiedInvoiceRequest_get_offer_id(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr);
+/* @internal */
+export function VerifiedInvoiceRequest_get_offer_id(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_get_offer_id(this_ptr);
+ return nativeResponseValue;
+}
+ // void VerifiedInvoiceRequest_set_offer_id(struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr, struct LDKOfferId val);
+/* @internal */
+export function VerifiedInvoiceRequest_set_offer_id(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_set_offer_id(this_ptr, val);
+ // debug statements here
+}
+ // uint64_t VerifiedInvoiceRequest_clone_ptr(LDKVerifiedInvoiceRequest *NONNULL_PTR arg);
+/* @internal */
+export function VerifiedInvoiceRequest_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKVerifiedInvoiceRequest VerifiedInvoiceRequest_clone(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR orig);
+/* @internal */
+export function VerifiedInvoiceRequest_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_clone(orig);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ UnsignedInvoiceRequest_chains(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_chains(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_chains(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_CVec_u8ZZ UnsignedInvoiceRequest_metadata(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_metadata(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_AmountZ UnsignedInvoiceRequest_amount(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_amount(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_amount(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_description(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_description(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_description(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKOfferFeatures UnsignedInvoiceRequest_offer_features(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_offer_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_offer_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_absolute_expiry(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_absolute_expiry(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_issuer(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_issuer(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_issuer(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_BlindedMessagePathZ UnsignedInvoiceRequest_paths(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_paths(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_paths(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKQuantity UnsignedInvoiceRequest_supported_quantity(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_supported_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_supported_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey UnsignedInvoiceRequest_signing_pubkey(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_signing_pubkey(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_signing_pubkey(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKu8slice UnsignedInvoiceRequest_payer_metadata(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_payer_metadata(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedInvoiceRequest_chain(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_chain(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_chain(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_amount_msats(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_amount_msats(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_amount_msats(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKInvoiceRequestFeatures UnsignedInvoiceRequest_invoice_request_features(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_invoice_request_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_quantity(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey UnsignedInvoiceRequest_payer_id(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_payer_id(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_id(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_payer_note(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function UnsignedInvoiceRequest_payer_note(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_note(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ InvoiceRequest_chains(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_chains(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_chains(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_CVec_u8ZZ InvoiceRequest_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_metadata(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_AmountZ InvoiceRequest_amount(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_amount(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_amount(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString InvoiceRequest_description(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_description(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_description(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKOfferFeatures InvoiceRequest_offer_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_offer_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_offer_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_absolute_expiry(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_absolute_expiry(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString InvoiceRequest_issuer(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_issuer(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_issuer(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_BlindedMessagePathZ InvoiceRequest_paths(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_paths(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_paths(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKQuantity InvoiceRequest_supported_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_supported_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_supported_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey InvoiceRequest_signing_pubkey(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_signing_pubkey(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_signing_pubkey(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKu8slice InvoiceRequest_payer_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_payer_metadata(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_payer_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes InvoiceRequest_chain(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_chain(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_chain(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_amount_msats(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_amount_msats(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_amount_msats(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequest_invoice_request_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_invoice_request_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey InvoiceRequest_payer_id(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_payer_id(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_payer_id(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString InvoiceRequest_payer_note(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_payer_note(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_payer_note(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ InvoiceRequest_respond_with_no_std(const struct LDKInvoiceRequest *NONNULL_PTR this_arg, struct LDKCVec_BlindedPaymentPathZ payment_paths, struct LDKThirtyTwoBytes payment_hash, uint64_t created_at);
+/* @internal */
+export function InvoiceRequest_respond_with_no_std(this_arg: bigint, payment_paths: number, payment_hash: number, created_at: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_respond_with_no_std(this_arg, payment_paths, payment_hash, created_at);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_VerifiedInvoiceRequestNoneZ InvoiceRequest_verify_using_metadata(struct LDKInvoiceRequest this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
+/* @internal */
+export function InvoiceRequest_verify_using_metadata(this_arg: bigint, key: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_verify_using_metadata(this_arg, key);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_VerifiedInvoiceRequestNoneZ InvoiceRequest_verify_using_recipient_data(struct LDKInvoiceRequest this_arg, struct LDKNonce nonce, const struct LDKExpandedKey *NONNULL_PTR key);
+/* @internal */
+export function InvoiceRequest_verify_using_recipient_data(this_arg: bigint, nonce: bigint, key: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_verify_using_recipient_data(this_arg, nonce, key);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKSchnorrSignature InvoiceRequest_signature(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function InvoiceRequest_signature(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_signature(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ VerifiedInvoiceRequest_chains(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_chains(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_chains(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_CVec_u8ZZ VerifiedInvoiceRequest_metadata(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_metadata(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_AmountZ VerifiedInvoiceRequest_amount(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_amount(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_amount(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_description(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_description(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_description(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKOfferFeatures VerifiedInvoiceRequest_offer_features(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_offer_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_offer_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_absolute_expiry(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_absolute_expiry(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_issuer(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_issuer(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_issuer(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_BlindedMessagePathZ VerifiedInvoiceRequest_paths(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_paths(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_paths(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKQuantity VerifiedInvoiceRequest_supported_quantity(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_supported_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_supported_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey VerifiedInvoiceRequest_signing_pubkey(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_signing_pubkey(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_signing_pubkey(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKu8slice VerifiedInvoiceRequest_payer_metadata(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_payer_metadata(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes VerifiedInvoiceRequest_chain(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_chain(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_chain(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_amount_msats(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_amount_msats(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_amount_msats(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKInvoiceRequestFeatures VerifiedInvoiceRequest_invoice_request_features(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_invoice_request_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_quantity(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey VerifiedInvoiceRequest_payer_id(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_payer_id(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_id(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_payer_note(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
+/* @internal */
+export function VerifiedInvoiceRequest_payer_note(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_note(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ VerifiedInvoiceRequest_respond_with_no_std(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg, struct LDKCVec_BlindedPaymentPathZ payment_paths, struct LDKThirtyTwoBytes payment_hash, uint64_t created_at);
+/* @internal */
+export function VerifiedInvoiceRequest_respond_with_no_std(this_arg: bigint, payment_paths: number, payment_hash: number, created_at: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_respond_with_no_std(this_arg, payment_paths, payment_hash, created_at);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ VerifiedInvoiceRequest_respond_using_derived_keys_no_std(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg, struct LDKCVec_BlindedPaymentPathZ payment_paths, struct LDKThirtyTwoBytes payment_hash, uint64_t created_at);
+/* @internal */
+export function VerifiedInvoiceRequest_respond_using_derived_keys_no_std(this_arg: bigint, payment_paths: number, payment_hash: number, created_at: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_respond_using_derived_keys_no_std(this_arg, payment_paths, payment_hash, created_at);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z UnsignedInvoiceRequest_write(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR obj);
+/* @internal */
+export function UnsignedInvoiceRequest_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z InvoiceRequest_write(const struct LDKInvoiceRequest *NONNULL_PTR obj);
+/* @internal */
+export function InvoiceRequest_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequest_write(obj);
+ return nativeResponseValue;
+}
+ // void InvoiceRequestFields_free(struct LDKInvoiceRequestFields this_obj);
+/* @internal */
+export function InvoiceRequestFields_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_free(this_obj);
+ // debug statements here
+}
+ // struct LDKPublicKey InvoiceRequestFields_get_payer_id(const struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr);
+/* @internal */
+export function InvoiceRequestFields_get_payer_id(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_get_payer_id(this_ptr);
+ return nativeResponseValue;
+}
+ // void InvoiceRequestFields_set_payer_id(struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+/* @internal */
+export function InvoiceRequestFields_set_payer_id(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_set_payer_id(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKCOption_u64Z InvoiceRequestFields_get_quantity(const struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr);
+/* @internal */
+export function InvoiceRequestFields_get_quantity(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_get_quantity(this_ptr);
+ return nativeResponseValue;
+}
+ // void InvoiceRequestFields_set_quantity(struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+/* @internal */
+export function InvoiceRequestFields_set_quantity(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_set_quantity(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKUntrustedString InvoiceRequestFields_get_payer_note_truncated(const struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr);
+/* @internal */
+export function InvoiceRequestFields_get_payer_note_truncated(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_get_payer_note_truncated(this_ptr);
+ return nativeResponseValue;
+}
+ // void InvoiceRequestFields_set_payer_note_truncated(struct LDKInvoiceRequestFields *NONNULL_PTR this_ptr, struct LDKUntrustedString val);
+/* @internal */
+export function InvoiceRequestFields_set_payer_note_truncated(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_set_payer_note_truncated(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKInvoiceRequestFields InvoiceRequestFields_new(struct LDKPublicKey payer_id_arg, struct LDKCOption_u64Z quantity_arg, struct LDKUntrustedString payer_note_truncated_arg);
+/* @internal */
+export function InvoiceRequestFields_new(payer_id_arg: number, quantity_arg: bigint, payer_note_truncated_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_new(payer_id_arg, quantity_arg, payer_note_truncated_arg);
+ return nativeResponseValue;
+}
+ // uint64_t InvoiceRequestFields_clone_ptr(LDKInvoiceRequestFields *NONNULL_PTR arg);
+/* @internal */
+export function InvoiceRequestFields_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKInvoiceRequestFields InvoiceRequestFields_clone(const struct LDKInvoiceRequestFields *NONNULL_PTR orig);
+/* @internal */
+export function InvoiceRequestFields_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_clone(orig);
+ return nativeResponseValue;
+}
+ // bool InvoiceRequestFields_eq(const struct LDKInvoiceRequestFields *NONNULL_PTR a, const struct LDKInvoiceRequestFields *NONNULL_PTR b);
+/* @internal */
+export function InvoiceRequestFields_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z InvoiceRequestFields_write(const struct LDKInvoiceRequestFields *NONNULL_PTR obj);
+/* @internal */
+export function InvoiceRequestFields_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InvoiceRequestFieldsDecodeErrorZ InvoiceRequestFields_read(struct LDKu8slice ser);
+/* @internal */
+export function InvoiceRequestFields_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceRequestFields_read(ser);
+ return nativeResponseValue;
+}
+ // void TaggedHash_free(struct LDKTaggedHash this_obj);
+/* @internal */
+export function TaggedHash_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TaggedHash_free(this_obj);
+ // debug statements here
+}
+ // uint64_t TaggedHash_clone_ptr(LDKTaggedHash *NONNULL_PTR arg);
+/* @internal */
+export function TaggedHash_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TaggedHash_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKTaggedHash TaggedHash_clone(const struct LDKTaggedHash *NONNULL_PTR orig);
+/* @internal */
+export function TaggedHash_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TaggedHash_clone(orig);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES const uint8_t (*TaggedHash_as_digest(const struct LDKTaggedHash *NONNULL_PTR this_arg))[32];
+/* @internal */
+export function TaggedHash_as_digest(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TaggedHash_as_digest(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKStr TaggedHash_tag(const struct LDKTaggedHash *NONNULL_PTR this_arg);
+/* @internal */
+export function TaggedHash_tag(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TaggedHash_tag(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes TaggedHash_merkle_root(const struct LDKTaggedHash *NONNULL_PTR this_arg);
+/* @internal */
+export function TaggedHash_merkle_root(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TaggedHash_merkle_root(this_arg);
+ return nativeResponseValue;
+}
+ // void SignError_free(struct LDKSignError this_ptr);
+/* @internal */
+export function SignError_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignError_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t SignError_clone_ptr(LDKSignError *NONNULL_PTR arg);
+/* @internal */
+export function SignError_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignError_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKSignError SignError_clone(const struct LDKSignError *NONNULL_PTR orig);
+/* @internal */
+export function SignError_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignError_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKSignError SignError_signing(void);
+/* @internal */
+export function SignError_signing(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignError_signing();
+ return nativeResponseValue;
+}
+ // struct LDKSignError SignError_verification(enum LDKSecp256k1Error a);
+/* @internal */
+export function SignError_verification(a: Secp256k1Error): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignError_verification(a);
+ return nativeResponseValue;
+}
+ // void Nonce_free(struct LDKNonce this_obj);
+/* @internal */
+export function Nonce_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Nonce_free(this_obj);
+ // debug statements here
+}
+ // uint64_t Nonce_clone_ptr(LDKNonce *NONNULL_PTR arg);
+/* @internal */
+export function Nonce_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Nonce_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKNonce Nonce_clone(const struct LDKNonce *NONNULL_PTR orig);
+/* @internal */
+export function Nonce_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Nonce_clone(orig);
+ return nativeResponseValue;
+}
+ // bool Nonce_eq(const struct LDKNonce *NONNULL_PTR a, const struct LDKNonce *NONNULL_PTR b);
+/* @internal */
+export function Nonce_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Nonce_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKNonce Nonce_from_entropy_source(struct LDKEntropySource entropy_source);
+/* @internal */
+export function Nonce_from_entropy_source(entropy_source: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Nonce_from_entropy_source(entropy_source);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKu8slice Nonce_as_slice(const struct LDKNonce *NONNULL_PTR this_arg);
+/* @internal */
+export function Nonce_as_slice(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Nonce_as_slice(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z Nonce_write(const struct LDKNonce *NONNULL_PTR obj);
+/* @internal */
+export function Nonce_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Nonce_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NonceDecodeErrorZ Nonce_read(struct LDKu8slice ser);
+/* @internal */
+export function Nonce_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Nonce_read(ser);
+ return nativeResponseValue;
+}
+ // void Bolt12ParseError_free(struct LDKBolt12ParseError this_obj);
+/* @internal */
+export function Bolt12ParseError_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12ParseError_free(this_obj);
+ // debug statements here
+}
+ // uint64_t Bolt12ParseError_clone_ptr(LDKBolt12ParseError *NONNULL_PTR arg);
+/* @internal */
+export function Bolt12ParseError_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12ParseError_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKBolt12ParseError Bolt12ParseError_clone(const struct LDKBolt12ParseError *NONNULL_PTR orig);
+/* @internal */
+export function Bolt12ParseError_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12ParseError_clone(orig);
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_clone(const enum LDKBolt12SemanticError *NONNULL_PTR orig);
+/* @internal */
+export function Bolt12SemanticError_clone(orig: bigint): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_clone(orig);
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_already_expired(void);
+/* @internal */
+export function Bolt12SemanticError_already_expired(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_already_expired();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_chain(void);
+/* @internal */
+export function Bolt12SemanticError_unsupported_chain(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_chain();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_chain(void);
+/* @internal */
+export function Bolt12SemanticError_unexpected_chain(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_chain();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_missing_amount(void);
+/* @internal */
+export function Bolt12SemanticError_missing_amount(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_amount();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_amount(void);
+/* @internal */
+export function Bolt12SemanticError_invalid_amount(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_amount();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_insufficient_amount(void);
+/* @internal */
+export function Bolt12SemanticError_insufficient_amount(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_insufficient_amount();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_amount(void);
+/* @internal */
+export function Bolt12SemanticError_unexpected_amount(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_amount();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_currency(void);
+/* @internal */
+export function Bolt12SemanticError_unsupported_currency(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_currency();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_unknown_required_features(void);
+/* @internal */
+export function Bolt12SemanticError_unknown_required_features(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_unknown_required_features();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_features(void);
+/* @internal */
+export function Bolt12SemanticError_unexpected_features(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_features();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_missing_description(void);
+/* @internal */
+export function Bolt12SemanticError_missing_description(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_description();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signing_pubkey(void);
+/* @internal */
+export function Bolt12SemanticError_missing_signing_pubkey(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signing_pubkey();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_signing_pubkey(void);
+/* @internal */
+export function Bolt12SemanticError_invalid_signing_pubkey(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_signing_pubkey();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_signing_pubkey(void);
+/* @internal */
+export function Bolt12SemanticError_unexpected_signing_pubkey(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_signing_pubkey();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_missing_quantity(void);
+/* @internal */
+export function Bolt12SemanticError_missing_quantity(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_quantity();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_quantity(void);
+/* @internal */
+export function Bolt12SemanticError_invalid_quantity(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_quantity();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_quantity(void);
+/* @internal */
+export function Bolt12SemanticError_unexpected_quantity(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_quantity();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_metadata(void);
+/* @internal */
+export function Bolt12SemanticError_invalid_metadata(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_metadata();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_metadata(void);
+/* @internal */
+export function Bolt12SemanticError_unexpected_metadata(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_metadata();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_metadata(void);
+/* @internal */
+export function Bolt12SemanticError_missing_payer_metadata(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_metadata();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_id(void);
+/* @internal */
+export function Bolt12SemanticError_missing_payer_id(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_id();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_duplicate_payment_id(void);
+/* @internal */
+export function Bolt12SemanticError_duplicate_payment_id(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_duplicate_payment_id();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_missing_paths(void);
+/* @internal */
+export function Bolt12SemanticError_missing_paths(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_paths();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_paths(void);
+/* @internal */
+export function Bolt12SemanticError_unexpected_paths(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_paths();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_pay_info(void);
+/* @internal */
+export function Bolt12SemanticError_invalid_pay_info(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_pay_info();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_missing_creation_time(void);
+/* @internal */
+export function Bolt12SemanticError_missing_creation_time(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_creation_time();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payment_hash(void);
+/* @internal */
+export function Bolt12SemanticError_missing_payment_hash(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payment_hash();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_payment_hash(void);
+/* @internal */
+export function Bolt12SemanticError_unexpected_payment_hash(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_payment_hash();
+ return nativeResponseValue;
+}
+ // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signature(void);
+/* @internal */
+export function Bolt12SemanticError_missing_signature(): Bolt12SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signature();
+ return nativeResponseValue;
+}
+ // void RefundMaybeWithDerivedMetadataBuilder_free(struct LDKRefundMaybeWithDerivedMetadataBuilder this_obj);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_free(this_obj);
+ // debug statements here
+}
+ // uint64_t RefundMaybeWithDerivedMetadataBuilder_clone_ptr(LDKRefundMaybeWithDerivedMetadataBuilder *NONNULL_PTR arg);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKRefundMaybeWithDerivedMetadataBuilder RefundMaybeWithDerivedMetadataBuilder_clone(const struct LDKRefundMaybeWithDerivedMetadataBuilder *NONNULL_PTR orig);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_clone(orig);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ RefundMaybeWithDerivedMetadataBuilder_new(struct LDKCVec_u8Z metadata, struct LDKPublicKey payer_id, uint64_t amount_msats);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_new(metadata: number, payer_id: number, amount_msats: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_new(metadata, payer_id, amount_msats);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ RefundMaybeWithDerivedMetadataBuilder_deriving_payer_id(struct LDKPublicKey node_id, const struct LDKExpandedKey *NONNULL_PTR expanded_key, struct LDKNonce nonce, uint64_t amount_msats, struct LDKThirtyTwoBytes payment_id);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_deriving_payer_id(node_id: number, expanded_key: bigint, nonce: bigint, amount_msats: bigint, payment_id: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_deriving_payer_id(node_id, expanded_key, nonce, amount_msats, payment_id);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_description(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, struct LDKStr description);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_description(this_arg: bigint, description: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_description(this_arg, description);
+ // debug statements here
+}
+ // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_absolute_expiry(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, uint64_t absolute_expiry);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_absolute_expiry(this_arg: bigint, absolute_expiry: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_absolute_expiry(this_arg, absolute_expiry);
+ // debug statements here
+}
+ // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_issuer(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, struct LDKStr issuer);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_issuer(this_arg: bigint, issuer: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_issuer(this_arg, issuer);
+ // debug statements here
+}
+ // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_path(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, struct LDKBlindedMessagePath path);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_path(this_arg: bigint, path: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_path(this_arg, path);
+ // debug statements here
+}
+ // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_chain(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, enum LDKNetwork network);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_chain(this_arg: bigint, network: Network): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_chain(this_arg, network);
+ // debug statements here
+}
+ // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_quantity(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, uint64_t quantity);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_quantity(this_arg: bigint, quantity: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_quantity(this_arg, quantity);
+ // debug statements here
+}
+ // MUST_USE_RES void RefundMaybeWithDerivedMetadataBuilder_payer_note(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg, struct LDKStr payer_note);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_payer_note(this_arg: bigint, payer_note: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_payer_note(this_arg, payer_note);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKCResult_RefundBolt12SemanticErrorZ RefundMaybeWithDerivedMetadataBuilder_build(struct LDKRefundMaybeWithDerivedMetadataBuilder this_arg);
+/* @internal */
+export function RefundMaybeWithDerivedMetadataBuilder_build(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RefundMaybeWithDerivedMetadataBuilder_build(this_arg);
+ return nativeResponseValue;
+}
+ // void Refund_free(struct LDKRefund this_obj);
+/* @internal */
+export function Refund_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_free(this_obj);
+ // debug statements here
+}
+ // uint64_t Refund_clone_ptr(LDKRefund *NONNULL_PTR arg);
+/* @internal */
+export function Refund_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKRefund Refund_clone(const struct LDKRefund *NONNULL_PTR orig);
+/* @internal */
+export function Refund_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_clone(orig);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString Refund_description(const struct LDKRefund *NONNULL_PTR this_arg);
+/* @internal */
+export function Refund_description(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_description(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z Refund_absolute_expiry(const struct LDKRefund *NONNULL_PTR this_arg);
+/* @internal */
+export function Refund_absolute_expiry(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_absolute_expiry(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES bool Refund_is_expired_no_std(const struct LDKRefund *NONNULL_PTR this_arg, uint64_t duration_since_epoch);
+/* @internal */
+export function Refund_is_expired_no_std(this_arg: bigint, duration_since_epoch: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_is_expired_no_std(this_arg, duration_since_epoch);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString Refund_issuer(const struct LDKRefund *NONNULL_PTR this_arg);
+/* @internal */
+export function Refund_issuer(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_issuer(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_BlindedMessagePathZ Refund_paths(const struct LDKRefund *NONNULL_PTR this_arg);
+/* @internal */
+export function Refund_paths(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_paths(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKu8slice Refund_payer_metadata(const struct LDKRefund *NONNULL_PTR this_arg);
+/* @internal */
+export function Refund_payer_metadata(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_payer_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes Refund_chain(const struct LDKRefund *NONNULL_PTR this_arg);
+/* @internal */
+export function Refund_chain(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_chain(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t Refund_amount_msats(const struct LDKRefund *NONNULL_PTR this_arg);
+/* @internal */
+export function Refund_amount_msats(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_amount_msats(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKInvoiceRequestFeatures Refund_features(const struct LDKRefund *NONNULL_PTR this_arg);
+/* @internal */
+export function Refund_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z Refund_quantity(const struct LDKRefund *NONNULL_PTR this_arg);
+/* @internal */
+export function Refund_quantity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_quantity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey Refund_payer_id(const struct LDKRefund *NONNULL_PTR this_arg);
+/* @internal */
+export function Refund_payer_id(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_payer_id(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPrintableString Refund_payer_note(const struct LDKRefund *NONNULL_PTR this_arg);
+/* @internal */
+export function Refund_payer_note(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_payer_note(this_arg);
+ return nativeResponseValue;
+}
+ // uint64_t Refund_hash(const struct LDKRefund *NONNULL_PTR o);
+/* @internal */
+export function Refund_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_hash(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RefundDecodeErrorZ Refund_read(struct LDKu8slice ser);
+/* @internal */
+export function Refund_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_read(ser);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z Refund_write(const struct LDKRefund *NONNULL_PTR obj);
+/* @internal */
+export function Refund_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RefundBolt12ParseErrorZ Refund_from_str(struct LDKStr s);
+/* @internal */
+export function Refund_from_str(s: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_from_str(s);
+ return nativeResponseValue;
+}
+ // struct LDKStr Refund_to_str(const struct LDKRefund *NONNULL_PTR o);
+/* @internal */
+export function Refund_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_to_str(o);
+ return nativeResponseValue;
+}
+ // enum LDKUtxoLookupError UtxoLookupError_clone(const enum LDKUtxoLookupError *NONNULL_PTR orig);
+/* @internal */
+export function UtxoLookupError_clone(orig: bigint): UtxoLookupError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoLookupError_clone(orig);
+ return nativeResponseValue;
+}
+ // enum LDKUtxoLookupError UtxoLookupError_unknown_chain(void);
+/* @internal */
+export function UtxoLookupError_unknown_chain(): UtxoLookupError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_chain();
+ return nativeResponseValue;
+}
+ // enum LDKUtxoLookupError UtxoLookupError_unknown_tx(void);
+/* @internal */
+export function UtxoLookupError_unknown_tx(): UtxoLookupError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_tx();
+ return nativeResponseValue;
+}
+ // void UtxoResult_free(struct LDKUtxoResult this_ptr);
+/* @internal */
+export function UtxoResult_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoResult_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg);
+/* @internal */
+export function UtxoResult_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoResult_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKUtxoResult UtxoResult_clone(const struct LDKUtxoResult *NONNULL_PTR orig);
+/* @internal */
+export function UtxoResult_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoResult_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKUtxoResult UtxoResult_sync(struct LDKCResult_TxOutUtxoLookupErrorZ a);
+/* @internal */
+export function UtxoResult_sync(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoResult_sync(a);
+ return nativeResponseValue;
+}
+ // struct LDKUtxoResult UtxoResult_async(struct LDKUtxoFuture a);
+/* @internal */
+export function UtxoResult_async(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoResult_async(a);
+ return nativeResponseValue;
+}
+ // void UtxoLookup_free(struct LDKUtxoLookup this_ptr);
+/* @internal */
+export function UtxoLookup_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoLookup_free(this_ptr);
+ // debug statements here
+}
+ // void UtxoFuture_free(struct LDKUtxoFuture this_obj);
+/* @internal */
+export function UtxoFuture_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoFuture_free(this_obj);
+ // debug statements here
+}
+ // uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg);
+/* @internal */
+export function UtxoFuture_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoFuture_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKUtxoFuture UtxoFuture_clone(const struct LDKUtxoFuture *NONNULL_PTR orig);
+/* @internal */
+export function UtxoFuture_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoFuture_clone(orig);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKUtxoFuture UtxoFuture_new(void);
+/* @internal */
+export function UtxoFuture_new(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UtxoFuture_new();
+ return nativeResponseValue;
+}
+ // 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 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_UtxoFuture_resolve_without_forwarding(this_arg, graph, result);
+ // 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);
+/* @internal */
+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_UtxoFuture_resolve(this_arg, graph, gossip, result);
+ // debug statements here
+}
+ // void NodeId_free(struct LDKNodeId this_obj);
+/* @internal */
+export function NodeId_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
+ // debug statements here
+}
+ // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
+/* @internal */
+export function NodeId_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
+/* @internal */
+export function NodeId_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_clone(orig);
+ return nativeResponseValue;
+}
+ // bool NodeId_eq(const struct LDKNodeId *NONNULL_PTR a, const struct LDKNodeId *NONNULL_PTR b);
+/* @internal */
+export function NodeId_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
+/* @internal */
+export function NodeId_from_pubkey(pubkey: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NodeIdDecodeErrorZ NodeId_from_slice(struct LDKu8slice bytes);
+/* @internal */
+export function NodeId_from_slice(bytes: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_from_slice(bytes);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
+/* @internal */
+export function NodeId_as_slice(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES const uint8_t (*NodeId_as_array(const struct LDKNodeId *NONNULL_PTR this_arg))[33];
+/* @internal */
+export function NodeId_as_array(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_as_array(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_PublicKeySecp256k1ErrorZ NodeId_as_pubkey(const struct LDKNodeId *NONNULL_PTR this_arg);
+/* @internal */
+export function NodeId_as_pubkey(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_as_pubkey(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKStr NodeId_to_str(const struct LDKNodeId *NONNULL_PTR o);
+/* @internal */
+export function NodeId_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_to_str(o);
+ return nativeResponseValue;
+}
+ // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
+/* @internal */
+export function NodeId_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_hash(o);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
+/* @internal */
+export function NodeId_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
+/* @internal */
+export function NodeId_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_read(ser);
+ return nativeResponseValue;
+}
+ // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
+/* @internal */
+export function NetworkGraph_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
+ // debug statements here
+}
+ // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
+/* @internal */
+export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
+ // debug statements here
+}
+ // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
+/* @internal */
+export function NetworkUpdate_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
+/* @internal */
+export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
+/* @internal */
+export function NetworkUpdate_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
+/* @internal */
+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_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
+ return nativeResponseValue;
+}
+ // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
+/* @internal */
+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_NetworkUpdate_node_failure(node_id, is_permanent);
+ return nativeResponseValue;
+}
+ // bool NetworkUpdate_eq(const struct LDKNetworkUpdate *NONNULL_PTR a, const struct LDKNetworkUpdate *NONNULL_PTR b);
+/* @internal */
+export function NetworkUpdate_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkUpdate_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
+/* @internal */
+export function NetworkUpdate_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
+/* @internal */
+export function NetworkUpdate_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
+ 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);
+/* @internal */
+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_P2PGossipSync_new(network_graph, utxo_lookup, logger);
+ return nativeResponseValue;
+}
+ // void P2PGossipSync_add_utxo_lookup(const struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_UtxoLookupZ utxo_lookup);
+/* @internal */
+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_P2PGossipSync_add_utxo_lookup(this_arg, utxo_lookup);
+ // debug statements here
+}
+ // void NetworkGraph_handle_network_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNetworkUpdate *NONNULL_PTR network_update);
+/* @internal */
+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_NetworkGraph_handle_network_update(this_arg, network_update);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes NetworkGraph_get_chain_hash(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
+/* @internal */
+export function NetworkGraph_get_chain_hash(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkGraph_get_chain_hash(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NoneLightningErrorZ verify_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
+/* @internal */
+export function verify_node_announcement(msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_verify_node_announcement(msg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NoneLightningErrorZ verify_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
+/* @internal */
+export function verify_channel_announcement(msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_verify_channel_announcement(msg);
+ return nativeResponseValue;
+}
+ // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
+/* @internal */
+export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
+/* @internal */
+export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
+ return nativeResponseValue;
+}
+ // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
+/* @internal */
+export function ChannelUpdateInfo_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
+ // debug statements here
+}
+ // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+/* @internal */
+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_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+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_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 ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+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_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
+/* @internal */
+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_ChannelUpdateInfo_set_fees(this_ptr, val);
+ // debug statements here
+}
+ // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
+/* @internal */
+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_ChannelUpdateInfo_set_last_update(this_ptr, val);
+ // debug statements here
+}
+ // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+/* @internal */
+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_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
+/* @internal */
+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_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
+ // debug statements here
+}
+ // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
+/* @internal */
+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_ChannelUpdateInfo_set_enabled(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
+/* @internal */
+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_ChannelUpdateInfo_get_last_update_message(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
+/* @internal */
+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_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKChannelUpdateInfo ChannelUpdateInfo_new(uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg, struct LDKRoutingFees fees_arg, uint32_t last_update_arg, uint16_t cltv_expiry_delta_arg, bool enabled_arg, struct LDKChannelUpdate last_update_message_arg);
+/* @internal */
+export function ChannelUpdateInfo_new(htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint, fees_arg: bigint, last_update_arg: number, cltv_expiry_delta_arg: number, enabled_arg: boolean, last_update_message_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_new(htlc_minimum_msat_arg, htlc_maximum_msat_arg, fees_arg, last_update_arg, cltv_expiry_delta_arg, enabled_arg, last_update_message_arg);
+ return nativeResponseValue;
+}
+ // uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
+/* @internal */
+export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
+/* @internal */
+export function ChannelUpdateInfo_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
+ return nativeResponseValue;
+}
+ // bool ChannelUpdateInfo_eq(const struct LDKChannelUpdateInfo *NONNULL_PTR a, const struct LDKChannelUpdateInfo *NONNULL_PTR b);
+/* @internal */
+export function ChannelUpdateInfo_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKStr ChannelUpdateInfo_to_str(const struct LDKChannelUpdateInfo *NONNULL_PTR o);
+/* @internal */
+export function ChannelUpdateInfo_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
+/* @internal */
+export function ChannelUpdateInfo_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
+/* @internal */
+export function ChannelUpdateInfo_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
+ return nativeResponseValue;
+}
+ // void ChannelInfo_free(struct LDKChannelInfo this_obj);
+/* @internal */
+export function ChannelInfo_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
+ // debug statements here
+}
+ // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelInfo_get_features(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
+/* @internal */
+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_ChannelInfo_set_features(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
+/* @internal */
+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_ChannelInfo_set_node_one(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
+/* @internal */
+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_ChannelInfo_set_node_two(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+/* @internal */
+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_ChannelInfo_set_capacity_sats(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 ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
+/* @internal */
+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_ChannelInfo_set_one_to_two(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+/* @internal */
+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_ChannelInfo_get_two_to_one(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
+/* @internal */
+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_ChannelInfo_set_two_to_one(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
+/* @internal */
+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_ChannelInfo_set_announcement_message(this_ptr, val);
+ // debug statements here
+}
+ // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
+/* @internal */
+export function ChannelInfo_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
+/* @internal */
+export function ChannelInfo_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
+ return nativeResponseValue;
+}
+ // bool ChannelInfo_eq(const struct LDKChannelInfo *NONNULL_PTR a, const struct LDKChannelInfo *NONNULL_PTR b);
+/* @internal */
+export function ChannelInfo_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
+/* @internal */
+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_ChannelInfo_get_directional_info(this_arg, channel_flags);
+ return nativeResponseValue;
+}
+ // struct LDKStr ChannelInfo_to_str(const struct LDKChannelInfo *NONNULL_PTR o);
+/* @internal */
+export function ChannelInfo_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
+/* @internal */
+export function ChannelInfo_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
+/* @internal */
+export function ChannelInfo_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
+ return nativeResponseValue;
+}
+ // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
+/* @internal */
+export function DirectedChannelInfo_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
+ // debug statements here
+}
+ // uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
+/* @internal */
+export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
+/* @internal */
+export function DirectedChannelInfo_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
+/* @internal */
+export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
+/* @internal */
+export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKNodeId DirectedChannelInfo_source(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
+/* @internal */
+export function DirectedChannelInfo_source(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DirectedChannelInfo_source(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKNodeId DirectedChannelInfo_target(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
+/* @internal */
+export function DirectedChannelInfo_target(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DirectedChannelInfo_target(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
+}
+ // uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
+/* @internal */
+export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
+/* @internal */
+export function EffectiveCapacity_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
+/* @internal */
+export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
+ return nativeResponseValue;
+}
+ // struct LDKEffectiveCapacity EffectiveCapacity_advertised_max_htlc(uint64_t amount_msat);
+/* @internal */
+export function EffectiveCapacity_advertised_max_htlc(amount_msat: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_EffectiveCapacity_advertised_max_htlc(amount_msat);
+ return nativeResponseValue;
+}
+ // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, uint64_t htlc_maximum_msat);
+/* @internal */
+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_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
+ return nativeResponseValue;
+}
+ // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
+/* @internal */
+export function EffectiveCapacity_infinite(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
+ return nativeResponseValue;
+}
+ // struct LDKEffectiveCapacity EffectiveCapacity_hint_max_htlc(uint64_t amount_msat);
+/* @internal */
+export function EffectiveCapacity_hint_max_htlc(amount_msat: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_EffectiveCapacity_hint_max_htlc(amount_msat);
+ return nativeResponseValue;
+}
+ // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
+/* @internal */
+export function EffectiveCapacity_unknown(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
+/* @internal */
+export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
+ 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 NodeAnnouncementDetails_free(struct LDKNodeAnnouncementDetails this_obj);
+/* @internal */
+export function NodeAnnouncementDetails_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_free(this_obj);
+ // debug statements here
+}
+ // struct LDKNodeFeatures NodeAnnouncementDetails_get_features(const struct LDKNodeAnnouncementDetails *NONNULL_PTR this_ptr);
+/* @internal */
+export function NodeAnnouncementDetails_get_features(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_get_features(this_ptr);
+ return nativeResponseValue;
+}
+ // void NodeAnnouncementDetails_set_features(struct LDKNodeAnnouncementDetails *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
+/* @internal */
+export function NodeAnnouncementDetails_set_features(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_set_features(this_ptr, val);
+ // debug statements here
+}
+ // uint32_t NodeAnnouncementDetails_get_last_update(const struct LDKNodeAnnouncementDetails *NONNULL_PTR this_ptr);
+/* @internal */
+export function NodeAnnouncementDetails_get_last_update(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_get_last_update(this_ptr);
+ return nativeResponseValue;
+}
+ // void NodeAnnouncementDetails_set_last_update(struct LDKNodeAnnouncementDetails *NONNULL_PTR this_ptr, uint32_t val);
+/* @internal */
+export function NodeAnnouncementDetails_set_last_update(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_set_last_update(this_ptr, val);
+ // debug statements here
+}
+ // const uint8_t (*NodeAnnouncementDetails_get_rgb(const struct LDKNodeAnnouncementDetails *NONNULL_PTR this_ptr))[3];
+/* @internal */
+export function NodeAnnouncementDetails_get_rgb(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_get_rgb(this_ptr);
+ return nativeResponseValue;
+}
+ // void NodeAnnouncementDetails_set_rgb(struct LDKNodeAnnouncementDetails *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
+/* @internal */
+export function NodeAnnouncementDetails_set_rgb(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_set_rgb(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKNodeAlias NodeAnnouncementDetails_get_alias(const struct LDKNodeAnnouncementDetails *NONNULL_PTR this_ptr);
+/* @internal */
+export function NodeAnnouncementDetails_get_alias(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_get_alias(this_ptr);
+ return nativeResponseValue;
+}
+ // void NodeAnnouncementDetails_set_alias(struct LDKNodeAnnouncementDetails *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
+/* @internal */
+export function NodeAnnouncementDetails_set_alias(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_set_alias(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKCVec_SocketAddressZ NodeAnnouncementDetails_get_addresses(const struct LDKNodeAnnouncementDetails *NONNULL_PTR this_ptr);
+/* @internal */
+export function NodeAnnouncementDetails_get_addresses(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_get_addresses(this_ptr);
+ return nativeResponseValue;
+}
+ // void NodeAnnouncementDetails_set_addresses(struct LDKNodeAnnouncementDetails *NONNULL_PTR this_ptr, struct LDKCVec_SocketAddressZ val);
+/* @internal */
+export function NodeAnnouncementDetails_set_addresses(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_set_addresses(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKNodeAnnouncementDetails NodeAnnouncementDetails_new(struct LDKNodeFeatures features_arg, uint32_t last_update_arg, struct LDKThreeBytes rgb_arg, struct LDKNodeAlias alias_arg, struct LDKCVec_SocketAddressZ addresses_arg);
+/* @internal */
+export function NodeAnnouncementDetails_new(features_arg: bigint, last_update_arg: number, rgb_arg: number, alias_arg: bigint, addresses_arg: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg);
+ return nativeResponseValue;
+}
+ // uint64_t NodeAnnouncementDetails_clone_ptr(LDKNodeAnnouncementDetails *NONNULL_PTR arg);
+/* @internal */
+export function NodeAnnouncementDetails_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKNodeAnnouncementDetails NodeAnnouncementDetails_clone(const struct LDKNodeAnnouncementDetails *NONNULL_PTR orig);
+/* @internal */
+export function NodeAnnouncementDetails_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_clone(orig);
+ return nativeResponseValue;
+}
+ // bool NodeAnnouncementDetails_eq(const struct LDKNodeAnnouncementDetails *NONNULL_PTR a, const struct LDKNodeAnnouncementDetails *NONNULL_PTR b);
+/* @internal */
+export function NodeAnnouncementDetails_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementDetails_eq(a, b);
+ return nativeResponseValue;
+}
+ // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_ptr);
+/* @internal */
+export function NodeAnnouncementInfo_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
+/* @internal */
+export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
+/* @internal */
+export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_relayed(struct LDKNodeAnnouncement a);
+/* @internal */
+export function NodeAnnouncementInfo_relayed(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_relayed(a);
+ return nativeResponseValue;
+}
+ // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_local(struct LDKNodeAnnouncementDetails a);
+/* @internal */
+export function NodeAnnouncementInfo_local(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_local(a);
+ return nativeResponseValue;
+}
+ // bool NodeAnnouncementInfo_eq(const struct LDKNodeAnnouncementInfo *NONNULL_PTR a, const struct LDKNodeAnnouncementInfo *NONNULL_PTR b);
+/* @internal */
+export function NodeAnnouncementInfo_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKNodeFeatures NodeAnnouncementInfo_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
+/* @internal */
+export function NodeAnnouncementInfo_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint32_t NodeAnnouncementInfo_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
+/* @internal */
+export function NodeAnnouncementInfo_last_update(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_last_update(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThreeBytes NodeAnnouncementInfo_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
+/* @internal */
+export function NodeAnnouncementInfo_rgb(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_rgb(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKNodeAlias NodeAnnouncementInfo_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
+/* @internal */
+export function NodeAnnouncementInfo_alias(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_alias(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_SocketAddressZ NodeAnnouncementInfo_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
+/* @internal */
+export function NodeAnnouncementInfo_addresses(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_addresses(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncementInfo_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
+/* @internal */
+export function NodeAnnouncementInfo_announcement_message(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_announcement_message(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
+/* @internal */
+export function NodeAnnouncementInfo_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
+/* @internal */
+export function NodeAnnouncementInfo_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
+ return nativeResponseValue;
+}
+ // void NodeAlias_free(struct LDKNodeAlias this_obj);
+/* @internal */
+export function NodeAlias_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
+ // debug statements here
+}
+ // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
+/* @internal */
+export function NodeAlias_get_a(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
+ return nativeResponseValue;
+}
+ // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+/* @internal */
+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_NodeAlias_set_a(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
+/* @internal */
+export function NodeAlias_new(a_arg: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
+ return nativeResponseValue;
+}
+ // uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
+/* @internal */
+export function NodeAlias_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
+/* @internal */
+export function NodeAlias_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t NodeAlias_hash(const struct LDKNodeAlias *NONNULL_PTR o);
+/* @internal */
+export function NodeAlias_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAlias_hash(o);
+ return nativeResponseValue;
+}
+ // bool NodeAlias_eq(const struct LDKNodeAlias *NONNULL_PTR a, const struct LDKNodeAlias *NONNULL_PTR b);
+/* @internal */
+export function NodeAlias_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKStr NodeAlias_to_str(const struct LDKNodeAlias *NONNULL_PTR o);
+/* @internal */
+export function NodeAlias_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAlias_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
+/* @internal */
+export function NodeAlias_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
+/* @internal */
+export function NodeAlias_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
+ return nativeResponseValue;
+}
+ // void NodeInfo_free(struct LDKNodeInfo this_obj);
+/* @internal */
+export function NodeInfo_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ 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;
+}
+ // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
+/* @internal */
+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_NodeInfo_set_channels(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKCOption_NodeAnnouncementInfoZ 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;
+}
+ // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCOption_NodeAnnouncementInfoZ val);
+/* @internal */
+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_NodeInfo_set_announcement_info(this_ptr, val);
+ // debug statements here
+}
+ // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
+/* @internal */
+export function NodeInfo_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
+/* @internal */
+export function NodeInfo_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
+ return nativeResponseValue;
+}
+ // bool NodeInfo_eq(const struct LDKNodeInfo *NONNULL_PTR a, const struct LDKNodeInfo *NONNULL_PTR b);
+/* @internal */
+export function NodeInfo_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeInfo_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES bool NodeInfo_is_tor_only(const struct LDKNodeInfo *NONNULL_PTR this_arg);
+/* @internal */
+export function NodeInfo_is_tor_only(this_arg: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeInfo_is_tor_only(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKStr NodeInfo_to_str(const struct LDKNodeInfo *NONNULL_PTR o);
+/* @internal */
+export function NodeInfo_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeInfo_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
+/* @internal */
+export function NodeInfo_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
+/* @internal */
+export function NodeInfo_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
+/* @internal */
+export function NetworkGraph_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
+/* @internal */
+export function NetworkGraph_read(ser: number, arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
+ return nativeResponseValue;
+}
+ // struct LDKStr NetworkGraph_to_str(const struct LDKNetworkGraph *NONNULL_PTR o);
+/* @internal */
+export function NetworkGraph_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkGraph_to_str(o);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(enum LDKNetwork network, struct LDKLogger logger);
+/* @internal */
+export function NetworkGraph_new(network: Network, logger: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkGraph_new(network, logger);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
+/* @internal */
+export function NetworkGraph_read_only(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
+/* @internal */
+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_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
+ return nativeResponseValue;
+}
+ // 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 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_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;
+}
+ // 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 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_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
+ return nativeResponseValue;
+}
+ // 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 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_NetworkGraph_update_channel_from_announcement(this_arg, msg, utxo_lookup);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_announcement_no_lookup(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg);
+/* @internal */
+export function NetworkGraph_update_channel_from_announcement_no_lookup(this_arg: bigint, msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement_no_lookup(this_arg, msg);
+ 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);
+/* @internal */
+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_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, utxo_lookup);
+ return nativeResponseValue;
+}
+ // 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 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_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
+ return nativeResponseValue;
+}
+ // void NetworkGraph_channel_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
+/* @internal */
+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_NetworkGraph_channel_failed_permanent(this_arg, short_channel_id);
+ // debug statements here
+}
+ // void NetworkGraph_node_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
+/* @internal */
+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_NetworkGraph_node_failed_permanent(this_arg, node_id);
+ // debug statements here
+}
+ // void NetworkGraph_remove_stale_channels_and_tracking_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
+/* @internal */
+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_NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg, current_time_unix);
+ // 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);
+/* @internal */
+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_NetworkGraph_update_channel(this_arg, msg);
+ 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);
+/* @internal */
+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_NetworkGraph_update_channel_unsigned(this_arg, msg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_verify_channel_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
+/* @internal */
+export function NetworkGraph_verify_channel_update(this_arg: bigint, msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkGraph_verify_channel_update(this_arg, msg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
+/* @internal */
+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_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
+/* @internal */
+export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
+ return nativeResponseValue;
+}
+ // 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_SocketAddressZZ 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 LDKEntropySource entropy_source, struct LDKLockableScore scorer, struct LDKProbabilisticScoringFeeParameters score_params);
+/* @internal */
+export function DefaultRouter_new(network_graph: bigint, logger: bigint, entropy_source: bigint, scorer: bigint, score_params: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, entropy_source, scorer, score_params);
+ 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;
+}
+ // struct LDKMessageRouter DefaultRouter_as_MessageRouter(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
+/* @internal */
+export function DefaultRouter_as_MessageRouter(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DefaultRouter_as_MessageRouter(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 LDKScoreLookUp 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 LDKScoreLookUp ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR this_arg);
+/* @internal */
+export function ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(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
+}
+ // void InFlightHtlcs_add_inflight_htlc(struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, uint64_t channel_scid, uint64_t used_msat);
+/* @internal */
+export function InFlightHtlcs_add_inflight_htlc(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint, used_msat: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InFlightHtlcs_add_inflight_htlc(this_arg, source, target, channel_scid, used_msat);
+ // 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
+}
+ // bool RouteHop_get_maybe_announced_channel(const struct LDKRouteHop *NONNULL_PTR this_ptr);
+/* @internal */
+export function RouteHop_get_maybe_announced_channel(this_ptr: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RouteHop_get_maybe_announced_channel(this_ptr);
+ return nativeResponseValue;
+}
+ // void RouteHop_set_maybe_announced_channel(struct LDKRouteHop *NONNULL_PTR this_ptr, bool val);
+/* @internal */
+export function RouteHop_set_maybe_announced_channel(this_ptr: bigint, val: boolean): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RouteHop_set_maybe_announced_channel(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, bool maybe_announced_channel_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, maybe_announced_channel_arg: boolean): 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, maybe_announced_channel_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 LDKRouteParameters Route_get_route_params(const struct LDKRoute *NONNULL_PTR this_ptr);
+/* @internal */
+export function Route_get_route_params(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Route_get_route_params(this_ptr);
+ return nativeResponseValue;
+}
+ // void Route_set_route_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKRouteParameters val);
+/* @internal */
+export function Route_set_route_params(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Route_set_route_params(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_PathZ paths_arg, struct LDKRouteParameters route_params_arg);
+/* @internal */
+export function Route_new(paths_arg: number, route_params_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Route_new(paths_arg, route_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!");