+ const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
+ // debug statements here
+}
+ // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
+/* @internal */
+export function ChannelMessageHandler_handle_channel_update(this_arg: bigint, their_node_id: number, msg: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
+ // debug statements here
+}
+ // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
+/* @internal */
+export function ChannelMessageHandler_handle_error(this_arg: bigint, their_node_id: number, msg: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
+ // debug statements here
+}
+ // LDKNodeFeatures ChannelMessageHandler_provided_node_features LDKChannelMessageHandler *NONNULL_PTR this_arg
+/* @internal */
+export function ChannelMessageHandler_provided_node_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_node_features(this_arg);
+ return nativeResponseValue;
+}
+ // LDKInitFeatures ChannelMessageHandler_provided_init_features LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
+/* @internal */
+export function ChannelMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_init_features(this_arg, their_node_id);
+ return nativeResponseValue;
+}
+ // LDKCOption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler_get_chain_hashes LDKChannelMessageHandler *NONNULL_PTR this_arg
+/* @internal */
+export function ChannelMessageHandler_get_chain_hashes(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelMessageHandler_get_chain_hashes(this_arg);
+ return nativeResponseValue;
+}
+/* @internal */
+export interface LDKOffersMessageHandler {
+ handle_message (message: bigint): bigint;
+ release_pending_messages (): number;
+}
+
+/* @internal */
+export function LDKOffersMessageHandler_new(impl: LDKOffersMessageHandler): [bigint, number] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ var new_obj_idx = js_objs.length;
+ for (var i = 0; i < js_objs.length; i++) {
+ if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+ }
+ js_objs[i] = new WeakRef(impl);
+ return [wasm.TS_LDKOffersMessageHandler_new(i), i];
+}
+ // LDKCOption_OffersMessageZ OffersMessageHandler_handle_message LDKOffersMessageHandler *NONNULL_PTR this_arg, struct LDKOffersMessage message
+/* @internal */
+export function OffersMessageHandler_handle_message(this_arg: bigint, message: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OffersMessageHandler_handle_message(this_arg, message);
+ return nativeResponseValue;
+}
+ // LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ OffersMessageHandler_release_pending_messages LDKOffersMessageHandler *NONNULL_PTR this_arg
+/* @internal */
+export function OffersMessageHandler_release_pending_messages(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OffersMessageHandler_release_pending_messages(this_arg);
+ return nativeResponseValue;
+}
+/* @internal */
+export interface LDKRoutingMessageHandler {
+ handle_node_announcement (msg: bigint): bigint;
+ handle_channel_announcement (msg: bigint): bigint;
+ handle_channel_update (msg: bigint): bigint;
+ get_next_channel_announcement (starting_point: bigint): bigint;
+ get_next_node_announcement (starting_point: bigint): bigint;
+ peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
+ handle_reply_channel_range (their_node_id: number, msg: bigint): bigint;
+ handle_reply_short_channel_ids_end (their_node_id: number, msg: bigint): bigint;
+ handle_query_channel_range (their_node_id: number, msg: bigint): bigint;
+ handle_query_short_channel_ids (their_node_id: number, msg: bigint): bigint;
+ processing_queue_high (): boolean;
+ provided_node_features (): bigint;
+ provided_init_features (their_node_id: number): bigint;
+}
+
+/* @internal */
+export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ var new_obj_idx = js_objs.length;
+ for (var i = 0; i < js_objs.length; i++) {
+ if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+ }
+ js_objs[i] = new WeakRef(impl);
+ return [wasm.TS_LDKRoutingMessageHandler_new(i, MessageSendEventsProvider), i];
+}
+ // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
+/* @internal */
+export function RoutingMessageHandler_handle_node_announcement(this_arg: bigint, msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
+ return nativeResponseValue;
+}
+ // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
+/* @internal */
+export function RoutingMessageHandler_handle_channel_announcement(this_arg: bigint, msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
+ return nativeResponseValue;
+}
+ // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
+/* @internal */
+export function RoutingMessageHandler_handle_channel_update(this_arg: bigint, msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
+ return nativeResponseValue;
+}
+ // LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point
+/* @internal */
+export function RoutingMessageHandler_get_next_channel_announcement(this_arg: bigint, starting_point: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcement(this_arg, starting_point);
+ return nativeResponseValue;
+}
+ // LDKNodeAnnouncement RoutingMessageHandler_get_next_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKNodeId starting_point
+/* @internal */
+export function RoutingMessageHandler_get_next_node_announcement(this_arg: bigint, starting_point: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcement(this_arg, starting_point);
+ return nativeResponseValue;
+}
+ // LDKCResult_NoneNoneZ RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
+/* @internal */
+export function RoutingMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
+ return nativeResponseValue;
+}
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
+/* @internal */
+export function RoutingMessageHandler_handle_reply_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
+ return nativeResponseValue;
+}
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
+/* @internal */
+export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
+ return nativeResponseValue;
+}
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
+/* @internal */
+export function RoutingMessageHandler_handle_query_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
+ return nativeResponseValue;
+}
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
+/* @internal */
+export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
+ return nativeResponseValue;
+}
+ // bool RoutingMessageHandler_processing_queue_high LDKRoutingMessageHandler *NONNULL_PTR this_arg
+/* @internal */
+export function RoutingMessageHandler_processing_queue_high(this_arg: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_processing_queue_high(this_arg);
+ return nativeResponseValue;
+}
+ // LDKNodeFeatures RoutingMessageHandler_provided_node_features LDKRoutingMessageHandler *NONNULL_PTR this_arg
+/* @internal */
+export function RoutingMessageHandler_provided_node_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_node_features(this_arg);
+ return nativeResponseValue;
+}
+ // LDKInitFeatures RoutingMessageHandler_provided_init_features LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
+/* @internal */
+export function RoutingMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_init_features(this_arg, their_node_id);
+ return nativeResponseValue;
+}
+/* @internal */
+export interface LDKOnionMessageHandler {
+ handle_onion_message (peer_node_id: number, msg: bigint): void;
+ next_onion_message_for_peer (peer_node_id: number): bigint;
+ peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
+ peer_disconnected (their_node_id: number): void;
+ provided_node_features (): bigint;
+ provided_init_features (their_node_id: number): bigint;
+}
+
+/* @internal */
+export function LDKOnionMessageHandler_new(impl: LDKOnionMessageHandler): [bigint, number] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ var new_obj_idx = js_objs.length;
+ for (var i = 0; i < js_objs.length; i++) {
+ if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+ }
+ js_objs[i] = new WeakRef(impl);
+ return [wasm.TS_LDKOnionMessageHandler_new(i), i];
+}
+ // void OnionMessageHandler_handle_onion_message LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg
+/* @internal */
+export function OnionMessageHandler_handle_onion_message(this_arg: bigint, peer_node_id: number, msg: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OnionMessageHandler_handle_onion_message(this_arg, peer_node_id, msg);
+ // debug statements here
+}
+ // LDKOnionMessage OnionMessageHandler_next_onion_message_for_peer LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
+/* @internal */
+export function OnionMessageHandler_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OnionMessageHandler_next_onion_message_for_peer(this_arg, peer_node_id);
+ return nativeResponseValue;
+}
+ // LDKCResult_NoneNoneZ OnionMessageHandler_peer_connected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
+/* @internal */
+export function OnionMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
+ return nativeResponseValue;
+}
+ // void OnionMessageHandler_peer_disconnected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
+/* @internal */
+export function OnionMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_disconnected(this_arg, their_node_id);
+ // debug statements here
+}
+ // LDKNodeFeatures OnionMessageHandler_provided_node_features LDKOnionMessageHandler *NONNULL_PTR this_arg
+/* @internal */
+export function OnionMessageHandler_provided_node_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_node_features(this_arg);
+ return nativeResponseValue;
+}
+ // LDKInitFeatures OnionMessageHandler_provided_init_features LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
+/* @internal */
+export function OnionMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_init_features(this_arg, their_node_id);
+ return nativeResponseValue;
+}
+/* @internal */
+export interface LDKCustomMessageReader {
+ read (message_type: number, buffer: number): bigint;
+}
+
+/* @internal */
+export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): [bigint, number] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ var new_obj_idx = js_objs.length;
+ for (var i = 0; i < js_objs.length; i++) {
+ if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+ }
+ js_objs[i] = new WeakRef(impl);
+ return [wasm.TS_LDKCustomMessageReader_new(i), i];
+}
+ // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
+/* @internal */
+export function CustomMessageReader_read(this_arg: bigint, message_type: number, buffer: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
+ return nativeResponseValue;
+}
+/* @internal */
+export interface LDKCustomMessageHandler {
+ handle_custom_message (msg: bigint, sender_node_id: number): bigint;
+ get_and_clear_pending_msg (): number;
+ provided_node_features (): bigint;
+ provided_init_features (their_node_id: number): bigint;
+}
+
+/* @internal */
+export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: number): [bigint, number] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ var new_obj_idx = js_objs.length;
+ for (var i = 0; i < js_objs.length; i++) {
+ if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+ }
+ js_objs[i] = new WeakRef(impl);
+ return [wasm.TS_LDKCustomMessageHandler_new(i, CustomMessageReader), i];
+}
+ // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
+/* @internal */
+export function CustomMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint, sender_node_id: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
+ return nativeResponseValue;
+}
+ // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
+/* @internal */
+export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
+ return nativeResponseValue;
+}
+ // LDKNodeFeatures CustomMessageHandler_provided_node_features LDKCustomMessageHandler *NONNULL_PTR this_arg
+/* @internal */
+export function CustomMessageHandler_provided_node_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_node_features(this_arg);
+ return nativeResponseValue;
+}
+ // LDKInitFeatures CustomMessageHandler_provided_init_features LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
+/* @internal */
+export function CustomMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_init_features(this_arg, their_node_id);
+ return nativeResponseValue;
+}
+/* @internal */
+export interface LDKCustomOnionMessageHandler {
+ handle_custom_message (msg: bigint): bigint;
+ read_custom_message (message_type: bigint, buffer: number): bigint;
+ release_pending_custom_messages (): number;
+}
+
+/* @internal */
+export function LDKCustomOnionMessageHandler_new(impl: LDKCustomOnionMessageHandler): [bigint, number] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ var new_obj_idx = js_objs.length;
+ for (var i = 0; i < js_objs.length; i++) {
+ if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+ }
+ js_objs[i] = new WeakRef(impl);
+ return [wasm.TS_LDKCustomOnionMessageHandler_new(i), i];
+}
+ // LDKCOption_OnionMessageContentsZ CustomOnionMessageHandler_handle_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, struct LDKOnionMessageContents msg
+/* @internal */
+export function CustomOnionMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_handle_custom_message(this_arg, msg);
+ return nativeResponseValue;
+}
+ // LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler_read_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, uint64_t message_type, struct LDKu8slice buffer
+/* @internal */
+export function CustomOnionMessageHandler_read_custom_message(this_arg: bigint, message_type: bigint, buffer: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_read_custom_message(this_arg, message_type, buffer);
+ return nativeResponseValue;
+}
+ // LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ CustomOnionMessageHandler_release_pending_custom_messages LDKCustomOnionMessageHandler *NONNULL_PTR this_arg
+/* @internal */
+export function CustomOnionMessageHandler_release_pending_custom_messages(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_release_pending_custom_messages(this_arg);
+ return nativeResponseValue;
+}
+/* @internal */
+export interface LDKSocketDescriptor {
+ send_data (data: number, resume_read: boolean): number;
+ disconnect_socket (): void;
+ eq (other_arg: bigint): boolean;
+ hash (): bigint;
+}
+
+/* @internal */
+export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): [bigint, number] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ var new_obj_idx = js_objs.length;
+ for (var i = 0; i < js_objs.length; i++) {
+ if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+ }
+ js_objs[i] = new WeakRef(impl);
+ return [wasm.TS_LDKSocketDescriptor_new(i), i];
+}
+ // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
+/* @internal */
+export function SocketDescriptor_send_data(this_arg: bigint, data: number, resume_read: boolean): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
+ return nativeResponseValue;
+}
+ // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
+/* @internal */
+export function SocketDescriptor_disconnect_socket(this_arg: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
+ // debug statements here
+}
+ // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
+/* @internal */
+export function SocketDescriptor_hash(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
+ return nativeResponseValue;
+}
+/* @internal */
+export class LDKEffectiveCapacity {
+ protected constructor() {}
+}
+/* @internal */
+export function LDKEffectiveCapacity_ty_from_ptr(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export class LDKPayee {
+ protected constructor() {}
+}
+/* @internal */
+export function LDKPayee_ty_from_ptr(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKPayee_ty_from_ptr(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKPayee_Blinded_get_route_hints(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_route_hints(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKPayee_Blinded_get_features(ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_features(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKPayee_Clear_get_node_id(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_node_id(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKPayee_Clear_get_route_hints(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_route_hints(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKPayee_Clear_get_features(ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_features(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKPayee_Clear_get_final_cltv_expiry_delta(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_final_cltv_expiry_delta(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export interface LDKScore {
+ write (): number;
+}
+
+/* @internal */
+export function LDKScore_new(impl: LDKScore, ScoreLookUp: number, ScoreUpdate: number): [bigint, number] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ var new_obj_idx = js_objs.length;
+ for (var i = 0; i < js_objs.length; i++) {
+ if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+ }
+ js_objs[i] = new WeakRef(impl);
+ return [wasm.TS_LDKScore_new(i, ScoreLookUp, ScoreUpdate), i];
+}
+ // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
+/* @internal */
+export function Score_write(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Score_write(this_arg);
+ return nativeResponseValue;
+}
+/* @internal */
+export interface LDKMessageRouter {
+ find_path (sender: number, peers: number, destination: bigint): bigint;
+}
+
+/* @internal */
+export function LDKMessageRouter_new(impl: LDKMessageRouter): [bigint, number] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ var new_obj_idx = js_objs.length;
+ for (var i = 0; i < js_objs.length; i++) {
+ if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+ }
+ js_objs[i] = new WeakRef(impl);
+ return [wasm.TS_LDKMessageRouter_new(i), i];
+}
+ // LDKCResult_OnionMessagePathNoneZ MessageRouter_find_path LDKMessageRouter *NONNULL_PTR this_arg, struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination
+/* @internal */
+export function MessageRouter_find_path(this_arg: bigint, sender: number, peers: number, destination: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MessageRouter_find_path(this_arg, sender, peers, destination);
+ return nativeResponseValue;
+}
+/* @internal */
+export interface LDKCoinSelectionSource {
+ select_confirmed_utxos (claim_id: number, must_spend: number, must_pay_to: number, target_feerate_sat_per_1000_weight: number): bigint;
+ sign_tx (tx: number): bigint;
+}
+
+/* @internal */
+export function LDKCoinSelectionSource_new(impl: LDKCoinSelectionSource): [bigint, number] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ var new_obj_idx = js_objs.length;
+ for (var i = 0; i < js_objs.length; i++) {
+ if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+ }
+ js_objs[i] = new WeakRef(impl);
+ return [wasm.TS_LDKCoinSelectionSource_new(i), i];
+}
+ // LDKCResult_CoinSelectionNoneZ CoinSelectionSource_select_confirmed_utxos LDKCoinSelectionSource *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes claim_id, struct LDKCVec_InputZ must_spend, struct LDKCVec_TxOutZ must_pay_to, uint32_t target_feerate_sat_per_1000_weight
+/* @internal */
+export function CoinSelectionSource_select_confirmed_utxos(this_arg: bigint, claim_id: number, must_spend: number, must_pay_to: number, target_feerate_sat_per_1000_weight: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CoinSelectionSource_select_confirmed_utxos(this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
+ return nativeResponseValue;
+}
+ // LDKCResult_TransactionNoneZ CoinSelectionSource_sign_tx LDKCoinSelectionSource *NONNULL_PTR this_arg, struct LDKTransaction tx
+/* @internal */
+export function CoinSelectionSource_sign_tx(this_arg: bigint, tx: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CoinSelectionSource_sign_tx(this_arg, tx);
+ return nativeResponseValue;
+}
+/* @internal */
+export interface LDKWalletSource {
+ list_confirmed_utxos (): bigint;
+ get_change_script (): bigint;
+ sign_tx (tx: number): bigint;
+}
+
+/* @internal */
+export function LDKWalletSource_new(impl: LDKWalletSource): [bigint, number] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ var new_obj_idx = js_objs.length;
+ for (var i = 0; i < js_objs.length; i++) {
+ if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
+ }
+ js_objs[i] = new WeakRef(impl);
+ return [wasm.TS_LDKWalletSource_new(i), i];
+}
+ // LDKCResult_CVec_UtxoZNoneZ WalletSource_list_confirmed_utxos LDKWalletSource *NONNULL_PTR this_arg
+/* @internal */
+export function WalletSource_list_confirmed_utxos(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_WalletSource_list_confirmed_utxos(this_arg);
+ return nativeResponseValue;
+}
+ // LDKCResult_CVec_u8ZNoneZ WalletSource_get_change_script LDKWalletSource *NONNULL_PTR this_arg
+/* @internal */
+export function WalletSource_get_change_script(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_WalletSource_get_change_script(this_arg);
+ return nativeResponseValue;
+}
+ // LDKCResult_TransactionNoneZ WalletSource_sign_tx LDKWalletSource *NONNULL_PTR this_arg, struct LDKTransaction tx
+/* @internal */
+export function WalletSource_sign_tx(this_arg: bigint, tx: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_WalletSource_sign_tx(this_arg, tx);
+ return nativeResponseValue;
+}
+/* @internal */
+export class LDKGossipSync {
+ protected constructor() {}
+}
+/* @internal */
+export function LDKGossipSync_ty_from_ptr(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKGossipSync_ty_from_ptr(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKGossipSync_P2P_get_p2p(ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKGossipSync_P2P_get_p2p(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKGossipSync_Rapid_get_rapid(ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKGossipSync_Rapid_get_rapid(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export class LDKFallback {
+ protected constructor() {}
+}
+/* @internal */
+export function LDKFallback_ty_from_ptr(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKFallback_SegWitProgram_get_version(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKFallback_SegWitProgram_get_program(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKFallback_ScriptHash_get_script_hash(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
+ return nativeResponseValue;
+}
+ // struct LDKStr _ldk_get_compiled_version(void);
+/* @internal */
+export function _ldk_get_compiled_version(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
+ return nativeResponseValue;
+}
+ // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
+/* @internal */
+export function _ldk_c_bindings_get_compiled_version(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
+ return nativeResponseValue;
+}
+ // struct LDKSixteenBytes U128_le_bytes(struct LDKU128 val);
+/* @internal */
+export function U128_le_bytes(val: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_U128_le_bytes(val);
+ return nativeResponseValue;
+}
+ // struct LDKU128 U128_new(struct LDKSixteenBytes le_bytes);
+/* @internal */
+export function U128_new(le_bytes: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_U128_new(le_bytes);
+ return nativeResponseValue;
+}
+ // struct LDKBigEndianScalar BigEndianScalar_new(struct LDKThirtyTwoBytes big_endian_bytes);
+/* @internal */
+export function BigEndianScalar_new(big_endian_bytes: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BigEndianScalar_new(big_endian_bytes);
+ return nativeResponseValue;
+}
+ // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
+/* @internal */
+export function Bech32Error_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
+/* @internal */
+export function Bech32Error_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
+ return nativeResponseValue;
+}
+ // void Bech32Error_free(struct LDKBech32Error o);
+/* @internal */
+export function Bech32Error_free(o: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bech32Error_free(o);
+ // debug statements here
+}
+ // void Transaction_free(struct LDKTransaction _res);
+/* @internal */
+export function Transaction_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Transaction_free(_res);
+ // debug statements here
+}
+ // void Witness_free(struct LDKWitness _res);
+/* @internal */
+export function Witness_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Witness_free(_res);
+ // debug statements here
+}
+ // void TxIn_free(struct LDKTxIn _res);
+/* @internal */
+export function TxIn_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TxIn_free(_res);
+ // debug statements here
+}
+ // struct LDKTxIn TxIn_new(struct LDKWitness witness, struct LDKCVec_u8Z script_sig, uint32_t sequence, struct LDKThirtyTwoBytes previous_txid, uint32_t previous_vout);
+/* @internal */
+export function TxIn_new(witness: number, script_sig: number, sequence: number, previous_txid: number, previous_vout: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TxIn_new(witness, script_sig, sequence, previous_txid, previous_vout);
+ return nativeResponseValue;
+}
+ // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
+/* @internal */
+export function TxOut_new(script_pubkey: number, value: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
+ return nativeResponseValue;
+}
+ // void TxOut_free(struct LDKTxOut _res);
+/* @internal */
+export function TxOut_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TxOut_free(_res);
+ // debug statements here
+}
+ // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
+/* @internal */
+export function TxOut_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
+/* @internal */
+export function TxOut_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TxOut_clone(orig);
+ return nativeResponseValue;
+}
+ // void Str_free(struct LDKStr _res);
+/* @internal */
+export function Str_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Str_free(_res);
+ // debug statements here
+}
+ // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
+/* @internal */
+export function COption_u64Z_some(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_u64Z COption_u64Z_none(void);
+/* @internal */
+export function COption_u64Z_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u64Z_none();
+ return nativeResponseValue;
+}
+ // void COption_u64Z_free(struct LDKCOption_u64Z _res);
+/* @internal */
+export function COption_u64Z_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
+/* @internal */
+export function COption_u64Z_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
+/* @internal */
+export function COption_u64Z_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_BlindedPathZ_free(struct LDKCVec_BlindedPathZ _res);
+/* @internal */
+export function CVec_BlindedPathZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_BlindedPathZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_ok(struct LDKRefund o);
+/* @internal */
+export function CResult_RefundBolt12ParseErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
+/* @internal */
+export function CResult_RefundBolt12ParseErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_RefundBolt12ParseErrorZ_is_ok(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RefundBolt12ParseErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RefundBolt12ParseErrorZ_free(struct LDKCResult_RefundBolt12ParseErrorZ _res);
+/* @internal */
+export function CResult_RefundBolt12ParseErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RefundBolt12ParseErrorZ_clone_ptr(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RefundBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_clone(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RefundBolt12ParseErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_ok(struct LDKRetry o);
+/* @internal */
+export function CResult_RetryDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_RetryDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_RetryDecodeErrorZ_is_ok(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RetryDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RetryDecodeErrorZ_free(struct LDKCResult_RetryDecodeErrorZ _res);
+/* @internal */
+export function CResult_RetryDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RetryDecodeErrorZ_clone_ptr(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RetryDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_clone(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RetryDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
+/* @internal */
+export function CResult_NoneAPIErrorZ_ok(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
+/* @internal */
+export function CResult_NoneAPIErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_NoneAPIErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
+/* @internal */
+export function CResult_NoneAPIErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_NoneAPIErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_NoneAPIErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
+/* @internal */
+export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
+ // debug statements here
+}
+ // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
+/* @internal */
+export function CVec_APIErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_some(struct LDKThirtyTwoBytes o);
+/* @internal */
+export function COption_ThirtyTwoBytesZ_some(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_none(void);
+/* @internal */
+export function COption_ThirtyTwoBytesZ_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_none();
+ return nativeResponseValue;
+}
+ // void COption_ThirtyTwoBytesZ_free(struct LDKCOption_ThirtyTwoBytesZ _res);
+/* @internal */
+export function COption_ThirtyTwoBytesZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_ThirtyTwoBytesZ_clone_ptr(LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_ThirtyTwoBytesZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_clone(const struct LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR orig);
+/* @internal */
+export function COption_ThirtyTwoBytesZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
+/* @internal */
+export function CVec_u8Z_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
+ // debug statements here
+}
+ // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_some(struct LDKCVec_u8Z o);
+/* @internal */
+export function COption_CVec_u8ZZ_some(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_none(void);
+/* @internal */
+export function COption_CVec_u8ZZ_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_none();
+ return nativeResponseValue;
+}
+ // void COption_CVec_u8ZZ_free(struct LDKCOption_CVec_u8ZZ _res);
+/* @internal */
+export function COption_CVec_u8ZZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_CVec_u8ZZ_clone_ptr(LDKCOption_CVec_u8ZZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_clone(const struct LDKCOption_CVec_u8ZZ *NONNULL_PTR orig);
+/* @internal */
+export function COption_CVec_u8ZZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_ok(struct LDKRecipientOnionFields o);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RecipientOnionFieldsDecodeErrorZ_free(struct LDKCResult_RecipientOnionFieldsDecodeErrorZ _res);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_clone(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t C2Tuple_u64CVec_u8ZZ_clone_ptr(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR arg);
+/* @internal */
+export function C2Tuple_u64CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_clone(const struct LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR orig);
+/* @internal */
+export function C2Tuple_u64CVec_u8ZZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_new(uint64_t a, struct LDKCVec_u8Z b);
+/* @internal */
+export function C2Tuple_u64CVec_u8ZZ_new(a: bigint, b: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple_u64CVec_u8ZZ_free(struct LDKC2Tuple_u64CVec_u8ZZ _res);
+/* @internal */
+export function C2Tuple_u64CVec_u8ZZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_free(_res);
+ // debug statements here
+}
+ // void CVec_C2Tuple_u64CVec_u8ZZZ_free(struct LDKCVec_C2Tuple_u64CVec_u8ZZZ _res);
+/* @internal */
+export function CVec_C2Tuple_u64CVec_u8ZZZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_C2Tuple_u64CVec_u8ZZZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_ok(struct LDKRecipientOnionFields o);
+/* @internal */
+export function CResult_RecipientOnionFieldsNoneZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_err(void);
+/* @internal */
+export function CResult_RecipientOnionFieldsNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_RecipientOnionFieldsNoneZ_is_ok(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RecipientOnionFieldsNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RecipientOnionFieldsNoneZ_free(struct LDKCResult_RecipientOnionFieldsNoneZ _res);
+/* @internal */
+export function CResult_RecipientOnionFieldsNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RecipientOnionFieldsNoneZ_clone_ptr(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RecipientOnionFieldsNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_clone(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RecipientOnionFieldsNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
+/* @internal */
+export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_some(struct LDKCVec_ThirtyTwoBytesZ o);
+/* @internal */
+export function COption_CVec_ThirtyTwoBytesZZ_some(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_none(void);
+/* @internal */
+export function COption_CVec_ThirtyTwoBytesZZ_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_none();
+ return nativeResponseValue;
+}
+ // void COption_CVec_ThirtyTwoBytesZZ_free(struct LDKCOption_CVec_ThirtyTwoBytesZZ _res);
+/* @internal */
+export function COption_CVec_ThirtyTwoBytesZZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_CVec_ThirtyTwoBytesZZ_clone_ptr(LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_CVec_ThirtyTwoBytesZZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_clone(const struct LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR orig);
+/* @internal */
+export function COption_CVec_ThirtyTwoBytesZZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_ok(struct LDKThirtyTwoBytes o);
+/* @internal */
+export function CResult_ThirtyTwoBytesNoneZ_ok(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_err(void);
+/* @internal */
+export function CResult_ThirtyTwoBytesNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_ThirtyTwoBytesNoneZ_is_ok(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_ThirtyTwoBytesNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_ThirtyTwoBytesNoneZ_free(struct LDKCResult_ThirtyTwoBytesNoneZ _res);
+/* @internal */
+export function CResult_ThirtyTwoBytesNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_ThirtyTwoBytesNoneZ_clone_ptr(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_ThirtyTwoBytesNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_clone(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_ThirtyTwoBytesNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_ok(struct LDKBlindedPayInfo o);
+/* @internal */
+export function CResult_BlindedPayInfoDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_BlindedPayInfoDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_BlindedPayInfoDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_BlindedPayInfoDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_BlindedPayInfoDecodeErrorZ_free(struct LDKCResult_BlindedPayInfoDecodeErrorZ _res);
+/* @internal */
+export function CResult_BlindedPayInfoDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_clone(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_BlindedPayInfoDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
+/* @internal */
+export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
+/* @internal */
+export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
+/* @internal */
+export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
+/* @internal */
+export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
+/* @internal */
+export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
+/* @internal */
+export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
+/* @internal */
+export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
+ // debug statements here
+}
+ // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
+/* @internal */
+export function CVec_TxOutZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
+/* @internal */
+export function COption_u32Z_some(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_u32Z COption_u32Z_none(void);
+/* @internal */
+export function COption_u32Z_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u32Z_none();
+ return nativeResponseValue;
+}
+ // void COption_u32Z_free(struct LDKCOption_u32Z _res);
+/* @internal */
+export function COption_u32Z_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
+/* @internal */
+export function COption_u32Z_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
+/* @internal */
+export function COption_u32Z_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t C2Tuple_CVec_u8ZusizeZ_clone_ptr(LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR arg);
+/* @internal */
+export function C2Tuple_CVec_u8ZusizeZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_CVec_u8ZusizeZ C2Tuple_CVec_u8ZusizeZ_clone(const struct LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR orig);
+/* @internal */
+export function C2Tuple_CVec_u8ZusizeZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_CVec_u8ZusizeZ C2Tuple_CVec_u8ZusizeZ_new(struct LDKCVec_u8Z a, uintptr_t b);
+/* @internal */
+export function C2Tuple_CVec_u8ZusizeZ_new(a: number, b: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple_CVec_u8ZusizeZ_free(struct LDKC2Tuple_CVec_u8ZusizeZ _res);
+/* @internal */
+export function C2Tuple_CVec_u8ZusizeZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok(struct LDKC2Tuple_CVec_u8ZusizeZ o);
+/* @internal */
+export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err(void);
+/* @internal */
+export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok(const struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ _res);
+/* @internal */
+export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(const struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_ok(struct LDKChannelDerivationParameters o);
+/* @internal */
+export function CResult_ChannelDerivationParametersDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_ChannelDerivationParametersDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_ChannelDerivationParametersDecodeErrorZ_free(struct LDKCResult_ChannelDerivationParametersDecodeErrorZ _res);
+/* @internal */
+export function CResult_ChannelDerivationParametersDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_ChannelDerivationParametersDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_ok(struct LDKHTLCDescriptor o);
+/* @internal */
+export function CResult_HTLCDescriptorDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_HTLCDescriptorDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_HTLCDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_HTLCDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_HTLCDescriptorDecodeErrorZ_free(struct LDKCResult_HTLCDescriptorDecodeErrorZ _res);
+/* @internal */
+export function CResult_HTLCDescriptorDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_clone(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_HTLCDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
+/* @internal */
+export function CResult_NoneNoneZ_ok(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
+/* @internal */
+export function CResult_NoneNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_NoneNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
+/* @internal */
+export function CResult_NoneNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_NoneNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_NoneNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_ECDSASignatureZ_free(struct LDKCVec_ECDSASignatureZ _res);
+/* @internal */
+export function CVec_ECDSASignatureZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_ECDSASignatureZ_free(_res);
+ // debug statements here
+}
+ // uint64_t C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR arg);
+/* @internal */
+export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(const struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR orig);
+/* @internal */
+export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(struct LDKECDSASignature a, struct LDKCVec_ECDSASignatureZ b);
+/* @internal */
+export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(a: number, b: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ _res);
+/* @internal */
+export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ o);
+/* @internal */
+export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err(void);
+/* @internal */
+export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ _res);
+/* @internal */
+export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_ok(struct LDKECDSASignature o);
+/* @internal */
+export function CResult_ECDSASignatureNoneZ_ok(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_err(void);
+/* @internal */
+export function CResult_ECDSASignatureNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_ECDSASignatureNoneZ_is_ok(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_ECDSASignatureNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_ECDSASignatureNoneZ_free(struct LDKCResult_ECDSASignatureNoneZ _res);
+/* @internal */
+export function CResult_ECDSASignatureNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_ECDSASignatureNoneZ_clone_ptr(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_ECDSASignatureNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_clone(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_ECDSASignatureNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_ok(struct LDKPublicKey o);
+/* @internal */
+export function CResult_PublicKeyNoneZ_ok(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_err(void);
+/* @internal */
+export function CResult_PublicKeyNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_PublicKeyNoneZ_is_ok(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_PublicKeyNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_PublicKeyNoneZ_free(struct LDKCResult_PublicKeyNoneZ _res);
+/* @internal */
+export function CResult_PublicKeyNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_PublicKeyNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_clone(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_PublicKeyNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_some(struct LDKBigEndianScalar o);
+/* @internal */
+export function COption_BigEndianScalarZ_some(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_none(void);
+/* @internal */
+export function COption_BigEndianScalarZ_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_none();
+ return nativeResponseValue;
+}
+ // void COption_BigEndianScalarZ_free(struct LDKCOption_BigEndianScalarZ _res);
+/* @internal */
+export function COption_BigEndianScalarZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_BigEndianScalarZ_clone_ptr(LDKCOption_BigEndianScalarZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_BigEndianScalarZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_clone(const struct LDKCOption_BigEndianScalarZ *NONNULL_PTR orig);
+/* @internal */
+export function COption_BigEndianScalarZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_U5Z_free(struct LDKCVec_U5Z _res);
+/* @internal */
+export function CVec_U5Z_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_U5Z_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
+/* @internal */
+export function CResult_RecoverableSignatureNoneZ_ok(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
+/* @internal */
+export function CResult_RecoverableSignatureNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RecoverableSignatureNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
+/* @internal */
+export function CResult_RecoverableSignatureNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RecoverableSignatureNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_ok(struct LDKSchnorrSignature o);
+/* @internal */
+export function CResult_SchnorrSignatureNoneZ_ok(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_err(void);
+/* @internal */
+export function CResult_SchnorrSignatureNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_SchnorrSignatureNoneZ_is_ok(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_SchnorrSignatureNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_SchnorrSignatureNoneZ_free(struct LDKCResult_SchnorrSignatureNoneZ _res);
+/* @internal */
+export function CResult_SchnorrSignatureNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_SchnorrSignatureNoneZ_clone_ptr(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_SchnorrSignatureNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_clone(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_SchnorrSignatureNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(struct LDKWriteableEcdsaChannelSigner o);
+/* @internal */
+export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ _res);
+/* @internal */
+export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_ok(struct LDKCVec_u8Z o);
+/* @internal */
+export function CResult_CVec_u8ZNoneZ_ok(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_err(void);
+/* @internal */
+export function CResult_CVec_u8ZNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_CVec_u8ZNoneZ_is_ok(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_CVec_u8ZNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_CVec_u8ZNoneZ_free(struct LDKCResult_CVec_u8ZNoneZ _res);
+/* @internal */
+export function CResult_CVec_u8ZNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_CVec_u8ZNoneZ_clone_ptr(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_CVec_u8ZNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_clone(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_CVec_u8ZNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_ok(struct LDKShutdownScript o);
+/* @internal */
+export function CResult_ShutdownScriptNoneZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_err(void);
+/* @internal */
+export function CResult_ShutdownScriptNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_ShutdownScriptNoneZ_is_ok(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_ShutdownScriptNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_ShutdownScriptNoneZ_free(struct LDKCResult_ShutdownScriptNoneZ _res);
+/* @internal */
+export function CResult_ShutdownScriptNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_ShutdownScriptNoneZ_clone_ptr(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_ShutdownScriptNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_clone(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_ShutdownScriptNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
+/* @internal */
+export function COption_u16Z_some(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_u16Z COption_u16Z_none(void);
+/* @internal */
+export function COption_u16Z_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u16Z_none();
+ return nativeResponseValue;
+}
+ // void COption_u16Z_free(struct LDKCOption_u16Z _res);
+/* @internal */
+export function COption_u16Z_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
+/* @internal */
+export function COption_u16Z_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
+/* @internal */
+export function COption_u16Z_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_boolZ COption_boolZ_some(bool o);
+/* @internal */
+export function COption_boolZ_some(o: boolean): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_boolZ_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_boolZ COption_boolZ_none(void);
+/* @internal */
+export function COption_boolZ_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_boolZ_none();
+ return nativeResponseValue;
+}
+ // void COption_boolZ_free(struct LDKCOption_boolZ _res);
+/* @internal */
+export function COption_boolZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_boolZ_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_boolZ_clone_ptr(LDKCOption_boolZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_boolZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_boolZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_boolZ COption_boolZ_clone(const struct LDKCOption_boolZ *NONNULL_PTR orig);
+/* @internal */
+export function COption_boolZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_boolZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
+/* @internal */
+export function CVec_CVec_u8ZZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
+/* @internal */
+export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
+/* @internal */
+export function CResult_CVec_CVec_u8ZZNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
+/* @internal */
+export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
+/* @internal */
+export function CResult_InMemorySignerDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_InMemorySignerDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
+/* @internal */
+export function CResult_InMemorySignerDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_InMemorySignerDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
+/* @internal */
+export function CResult_TransactionNoneZ_ok(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
+/* @internal */
+export function CResult_TransactionNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_TransactionNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
+/* @internal */
+export function CResult_TransactionNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_TransactionNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_TransactionNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
+/* @internal */
+export function CVec_ChannelDetailsZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
+/* @internal */
+export function CResult_RouteLightningErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
+/* @internal */
+export function CResult_RouteLightningErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RouteLightningErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
+/* @internal */
+export function CResult_RouteLightningErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RouteLightningErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
+/* @internal */
+export function CResult_InFlightHtlcsDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_InFlightHtlcsDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_InFlightHtlcsDecodeErrorZ_is_ok(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_InFlightHtlcsDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_InFlightHtlcsDecodeErrorZ_free(struct LDKCResult_InFlightHtlcsDecodeErrorZ _res);
+/* @internal */
+export function CResult_InFlightHtlcsDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_clone(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_InFlightHtlcsDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
+/* @internal */
+export function CResult_RouteHopDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_RouteHopDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RouteHopDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
+/* @internal */
+export function CResult_RouteHopDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_BlindedHopZ_free(struct LDKCVec_BlindedHopZ _res);
+/* @internal */
+export function CVec_BlindedHopZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_BlindedHopZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_ok(struct LDKBlindedTail o);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_BlindedTailDecodeErrorZ_is_ok(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_BlindedTailDecodeErrorZ_free(struct LDKCResult_BlindedTailDecodeErrorZ _res);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_BlindedTailDecodeErrorZ_clone_ptr(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_clone(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_BlindedTailDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
+/* @internal */
+export function CVec_RouteHopZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
+ // debug statements here
+}
+ // void CVec_PathZ_free(struct LDKCVec_PathZ _res);
+/* @internal */
+export function CVec_PathZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_PathZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
+/* @internal */
+export function CResult_RouteDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_RouteDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RouteDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
+/* @internal */
+export function CResult_RouteDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RouteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RouteDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
+/* @internal */
+export function CResult_RouteParametersDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_RouteParametersDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RouteParametersDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
+/* @internal */
+export function CResult_RouteParametersDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
+/* @internal */
+export function CVec_u64Z_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
+/* @internal */
+export function CResult_PaymentParametersDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_PaymentParametersDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
+/* @internal */
+export function CResult_PaymentParametersDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR arg);
+/* @internal */
+export function C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_clone(const struct LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR orig);
+/* @internal */
+export function C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_new(struct LDKBlindedPayInfo a, struct LDKBlindedPath b);
+/* @internal */
+export function C2Tuple_BlindedPayInfoBlindedPathZ_new(a: bigint, b: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple_BlindedPayInfoBlindedPathZ_free(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ _res);
+/* @internal */
+export function C2Tuple_BlindedPayInfoBlindedPathZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_free(_res);
+ // debug statements here
+}
+ // void CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ _res);
+/* @internal */
+export function CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res);
+ // debug statements here
+}
+ // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
+/* @internal */
+export function CVec_RouteHintZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
+ // debug statements here
+}
+ // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
+/* @internal */
+export function CVec_RouteHintHopZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
+/* @internal */
+export function CResult_RouteHintDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_RouteHintDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RouteHintDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
+/* @internal */
+export function CResult_RouteHintDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RouteHintDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
+/* @internal */
+export function CResult_RouteHintHopDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_RouteHintHopDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
+/* @internal */
+export function CResult_RouteHintHopDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
+/* @internal */
+export function CVec_PublicKeyZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
+/* @internal */
+export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
+/* @internal */
+export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
+/* @internal */
+export function CVec_NodeIdZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
+ // debug statements here
+}
+ // uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
+/* @internal */
+export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
+/* @internal */
+export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
+/* @internal */
+export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
+/* @internal */
+export function C2Tuple_u64u64Z_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
+ // debug statements here
+}
+ // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
+/* @internal */
+export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
+/* @internal */
+export function COption_C2Tuple_u64u64ZZ_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
+ return nativeResponseValue;
+}
+ // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
+/* @internal */
+export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
+/* @internal */
+export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_Z C2Tuple_Z_new(struct LDKThirtyTwoU16s a, struct LDKThirtyTwoU16s b);
+/* @internal */
+export function C2Tuple_Z_new(a: number, b: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_Z_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple_Z_free(struct LDKC2Tuple_Z _res);
+/* @internal */
+export function C2Tuple_Z_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_Z_free(_res);
+ // debug statements here
+}
+ // struct LDKC2Tuple__u1632_u1632Z C2Tuple__u1632_u1632Z_new(struct LDKThirtyTwoU16s a, struct LDKThirtyTwoU16s b);
+/* @internal */
+export function C2Tuple__u1632_u1632Z_new(a: number, b: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple__u1632_u1632Z_free(struct LDKC2Tuple__u1632_u1632Z _res);
+/* @internal */
+export function C2Tuple__u1632_u1632Z_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_free(_res);
+ // debug statements here
+}
+ // struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(struct LDKC2Tuple__u1632_u1632Z o);
+/* @internal */
+export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none(void);
+/* @internal */
+export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none();
+ return nativeResponseValue;
+}
+ // void COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ _res);
+/* @internal */
+export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCOption_f64Z COption_f64Z_some(double o);
+/* @internal */
+export function COption_f64Z_some(o: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_f64Z_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_f64Z COption_f64Z_none(void);
+/* @internal */
+export function COption_f64Z_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_f64Z_none();
+ return nativeResponseValue;
+}
+ // void COption_f64Z_free(struct LDKCOption_f64Z _res);
+/* @internal */
+export function COption_f64Z_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_f64Z_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_f64Z_clone_ptr(LDKCOption_f64Z *NONNULL_PTR arg);
+/* @internal */
+export function COption_f64Z_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_f64Z_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_f64Z COption_f64Z_clone(const struct LDKCOption_f64Z *NONNULL_PTR orig);
+/* @internal */
+export function COption_f64Z_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_f64Z_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
+/* @internal */
+export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
+/* @internal */
+export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
+/* @internal */
+export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
+/* @internal */
+export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
+/* @internal */
+export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
+/* @internal */
+export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
+ // debug statements here
+}
+ // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
+/* @internal */
+export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
+ // debug statements here
+}
+ // uint64_t C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR arg);
+/* @internal */
+export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR orig);
+/* @internal */
+export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new(struct LDKThirtyTwoBytes a, struct LDKCOption_ThirtyTwoBytesZ b);
+/* @internal */
+export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new(a: number, b: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ _res);
+/* @internal */
+export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(_res);
+ // debug statements here
+}
+ // void CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ _res);
+/* @internal */
+export function CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_ok(enum LDKChannelMonitorUpdateStatus o);
+/* @internal */
+export function CResult_ChannelMonitorUpdateStatusNoneZ_ok(o: ChannelMonitorUpdateStatus): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_err(void);
+/* @internal */
+export function CResult_ChannelMonitorUpdateStatusNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_ChannelMonitorUpdateStatusNoneZ_free(struct LDKCResult_ChannelMonitorUpdateStatusNoneZ _res);
+/* @internal */
+export function CResult_ChannelMonitorUpdateStatusNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_clone(const struct LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_ChannelMonitorUpdateStatusNoneZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
+/* @internal */
+export function CVec_MonitorEventZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
+ // debug statements here
+}
+ // uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
+/* @internal */
+export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
+/* @internal */
+export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
+/* @internal */
+export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
+ return nativeResponseValue;
+}
+ // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
+/* @internal */
+export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
+ // debug statements here
+}
+ // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
+/* @internal */
+export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
+/* @internal */
+export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
+/* @internal */
+export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
+/* @internal */
+export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
+/* @internal */
+export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
+/* @internal */
+export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
+/* @internal */
+export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt11InvoiceFeatures o);
+/* @internal */
+export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ _res);
+/* @internal */
+export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt12InvoiceFeatures o);
+/* @internal */
+export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ _res);
+/* @internal */
+export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_ok(struct LDKBlindedHopFeatures o);
+/* @internal */
+export function CResult_BlindedHopFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_BlindedHopFeaturesDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_BlindedHopFeaturesDecodeErrorZ_free(struct LDKCResult_BlindedHopFeaturesDecodeErrorZ _res);
+/* @internal */
+export function CResult_BlindedHopFeaturesDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_clone(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
+/* @internal */
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
+/* @internal */
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_ok(struct LDKOffer o);
+/* @internal */
+export function CResult_OfferBolt12ParseErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
+/* @internal */
+export function CResult_OfferBolt12ParseErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_OfferBolt12ParseErrorZ_is_ok(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_OfferBolt12ParseErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_OfferBolt12ParseErrorZ_free(struct LDKCResult_OfferBolt12ParseErrorZ _res);
+/* @internal */
+export function CResult_OfferBolt12ParseErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_OfferBolt12ParseErrorZ_clone_ptr(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_OfferBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_clone(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_OfferBolt12ParseErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone(orig);