X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=blobdiff_plain;f=lightning-c-bindings%2Finclude%2Flightningpp.hpp;h=d00d2381ea9b89f4e203ac717cac5cddc963af5e;hp=008b0f40bd1d25172c547b228901581b30432da9;hb=1926a7a71ae0f37ebd6562996769334e0af0cf1b;hpb=ea2409237d116fb016af8f2e7e26f12014157450

diff --git a/lightning-c-bindings/include/lightningpp.hpp b/lightning-c-bindings/include/lightningpp.hpp
index 008b0f4..d00d238 100644
--- a/lightning-c-bindings/include/lightningpp.hpp
+++ b/lightning-c-bindings/include/lightningpp.hpp
@@ -1,5 +1,65 @@
 #include <string.h>
 namespace LDK {
+class ChannelHandshakeConfig {
+private:
+	LDKChannelHandshakeConfig self;
+public:
+	ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
+	ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
+	ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
+	operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
+	~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
+	ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
+	LDKChannelHandshakeConfig* operator &() { return &self; }
+	LDKChannelHandshakeConfig* operator ->() { return &self; }
+	const LDKChannelHandshakeConfig* operator &() const { return &self; }
+	const LDKChannelHandshakeConfig* operator ->() const { return &self; }
+};
+class ChannelHandshakeLimits {
+private:
+	LDKChannelHandshakeLimits self;
+public:
+	ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
+	ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
+	ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
+	operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
+	~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
+	ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
+	LDKChannelHandshakeLimits* operator &() { return &self; }
+	LDKChannelHandshakeLimits* operator ->() { return &self; }
+	const LDKChannelHandshakeLimits* operator &() const { return &self; }
+	const LDKChannelHandshakeLimits* operator ->() const { return &self; }
+};
+class ChannelConfig {
+private:
+	LDKChannelConfig self;
+public:
+	ChannelConfig(const ChannelConfig&) = delete;
+	ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
+	ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
+	operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
+	~ChannelConfig() { ChannelConfig_free(self); }
+	ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
+	LDKChannelConfig* operator &() { return &self; }
+	LDKChannelConfig* operator ->() { return &self; }
+	const LDKChannelConfig* operator &() const { return &self; }
+	const LDKChannelConfig* operator ->() const { return &self; }
+};
+class UserConfig {
+private:
+	LDKUserConfig self;
+public:
+	UserConfig(const UserConfig&) = delete;
+	UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
+	UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
+	operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
+	~UserConfig() { UserConfig_free(self); }
+	UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
+	LDKUserConfig* operator &() { return &self; }
+	LDKUserConfig* operator ->() { return &self; }
+	const LDKUserConfig* operator &() const { return &self; }
+	const LDKUserConfig* operator ->() const { return &self; }
+};
 class APIError {
 private:
 	LDKAPIError self;
@@ -15,6 +75,21 @@ public:
 	const LDKAPIError* operator &() const { return &self; }
 	const LDKAPIError* operator ->() const { return &self; }
 };
+class OutPoint {
+private:
+	LDKOutPoint self;
+public:
+	OutPoint(const OutPoint&) = delete;
+	OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
+	OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
+	operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
+	~OutPoint() { OutPoint_free(self); }
+	OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
+	LDKOutPoint* operator &() { return &self; }
+	LDKOutPoint* operator ->() { return &self; }
+	const LDKOutPoint* operator &() const { return &self; }
+	const LDKOutPoint* operator ->() const { return &self; }
+};
 class TxCreationKeys {
 private:
 	LDKTxCreationKeys self;
@@ -165,6 +240,421 @@ public:
 	const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
 	const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
 };
+class Invoice {
+private:
+	LDKInvoice self;
+public:
+	Invoice(const Invoice&) = delete;
+	Invoice(Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Invoice)); }
+	Invoice(LDKInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoice)); }
+	operator LDKInvoice() && { LDKInvoice res = self; memset(&self, 0, sizeof(LDKInvoice)); return res; }
+	~Invoice() { Invoice_free(self); }
+	Invoice& operator=(Invoice&& o) { Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Invoice)); return *this; }
+	LDKInvoice* operator &() { return &self; }
+	LDKInvoice* operator ->() { return &self; }
+	const LDKInvoice* operator &() const { return &self; }
+	const LDKInvoice* operator ->() const { return &self; }
+};
+class SignedRawInvoice {
+private:
+	LDKSignedRawInvoice self;
+public:
+	SignedRawInvoice(const SignedRawInvoice&) = delete;
+	SignedRawInvoice(SignedRawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawInvoice)); }
+	SignedRawInvoice(LDKSignedRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawInvoice)); }
+	operator LDKSignedRawInvoice() && { LDKSignedRawInvoice res = self; memset(&self, 0, sizeof(LDKSignedRawInvoice)); return res; }
+	~SignedRawInvoice() { SignedRawInvoice_free(self); }
+	SignedRawInvoice& operator=(SignedRawInvoice&& o) { SignedRawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawInvoice)); return *this; }
+	LDKSignedRawInvoice* operator &() { return &self; }
+	LDKSignedRawInvoice* operator ->() { return &self; }
+	const LDKSignedRawInvoice* operator &() const { return &self; }
+	const LDKSignedRawInvoice* operator ->() const { return &self; }
+};
+class RawInvoice {
+private:
+	LDKRawInvoice self;
+public:
+	RawInvoice(const RawInvoice&) = delete;
+	RawInvoice(RawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawInvoice)); }
+	RawInvoice(LDKRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawInvoice)); }
+	operator LDKRawInvoice() && { LDKRawInvoice res = self; memset(&self, 0, sizeof(LDKRawInvoice)); return res; }
+	~RawInvoice() { RawInvoice_free(self); }
+	RawInvoice& operator=(RawInvoice&& o) { RawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(RawInvoice)); return *this; }
+	LDKRawInvoice* operator &() { return &self; }
+	LDKRawInvoice* operator ->() { return &self; }
+	const LDKRawInvoice* operator &() const { return &self; }
+	const LDKRawInvoice* operator ->() const { return &self; }
+};
+class RawDataPart {
+private:
+	LDKRawDataPart self;
+public:
+	RawDataPart(const RawDataPart&) = delete;
+	RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
+	RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
+	operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
+	~RawDataPart() { RawDataPart_free(self); }
+	RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
+	LDKRawDataPart* operator &() { return &self; }
+	LDKRawDataPart* operator ->() { return &self; }
+	const LDKRawDataPart* operator &() const { return &self; }
+	const LDKRawDataPart* operator ->() const { return &self; }
+};
+class PositiveTimestamp {
+private:
+	LDKPositiveTimestamp self;
+public:
+	PositiveTimestamp(const PositiveTimestamp&) = delete;
+	PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
+	PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
+	operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
+	~PositiveTimestamp() { PositiveTimestamp_free(self); }
+	PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
+	LDKPositiveTimestamp* operator &() { return &self; }
+	LDKPositiveTimestamp* operator ->() { return &self; }
+	const LDKPositiveTimestamp* operator &() const { return &self; }
+	const LDKPositiveTimestamp* operator ->() const { return &self; }
+};
+class SiPrefix {
+private:
+	LDKSiPrefix self;
+public:
+	SiPrefix(const SiPrefix&) = delete;
+	SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
+	SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
+	operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
+	SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
+	LDKSiPrefix* operator &() { return &self; }
+	LDKSiPrefix* operator ->() { return &self; }
+	const LDKSiPrefix* operator &() const { return &self; }
+	const LDKSiPrefix* operator ->() const { return &self; }
+};
+class Currency {
+private:
+	LDKCurrency self;
+public:
+	Currency(const Currency&) = delete;
+	Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
+	Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
+	operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
+	Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
+	LDKCurrency* operator &() { return &self; }
+	LDKCurrency* operator ->() { return &self; }
+	const LDKCurrency* operator &() const { return &self; }
+	const LDKCurrency* operator ->() const { return &self; }
+};
+class Sha256 {
+private:
+	LDKSha256 self;
+public:
+	Sha256(const Sha256&) = delete;
+	Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
+	Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
+	operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
+	~Sha256() { Sha256_free(self); }
+	Sha256& operator=(Sha256&& o) { Sha256_free(self); self = o.self; memset(&o, 0, sizeof(Sha256)); return *this; }
+	LDKSha256* operator &() { return &self; }
+	LDKSha256* operator ->() { return &self; }
+	const LDKSha256* operator &() const { return &self; }
+	const LDKSha256* operator ->() const { return &self; }
+};
+class Description {
+private:
+	LDKDescription self;
+public:
+	Description(const Description&) = delete;
+	Description(Description&& o) : self(o.self) { memset(&o, 0, sizeof(Description)); }
+	Description(LDKDescription&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDescription)); }
+	operator LDKDescription() && { LDKDescription res = self; memset(&self, 0, sizeof(LDKDescription)); return res; }
+	~Description() { Description_free(self); }
+	Description& operator=(Description&& o) { Description_free(self); self = o.self; memset(&o, 0, sizeof(Description)); return *this; }
+	LDKDescription* operator &() { return &self; }
+	LDKDescription* operator ->() { return &self; }
+	const LDKDescription* operator &() const { return &self; }
+	const LDKDescription* operator ->() const { return &self; }
+};
+class PayeePubKey {
+private:
+	LDKPayeePubKey self;
+public:
+	PayeePubKey(const PayeePubKey&) = delete;
+	PayeePubKey(PayeePubKey&& o) : self(o.self) { memset(&o, 0, sizeof(PayeePubKey)); }
+	PayeePubKey(LDKPayeePubKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayeePubKey)); }
+	operator LDKPayeePubKey() && { LDKPayeePubKey res = self; memset(&self, 0, sizeof(LDKPayeePubKey)); return res; }
+	~PayeePubKey() { PayeePubKey_free(self); }
+	PayeePubKey& operator=(PayeePubKey&& o) { PayeePubKey_free(self); self = o.self; memset(&o, 0, sizeof(PayeePubKey)); return *this; }
+	LDKPayeePubKey* operator &() { return &self; }
+	LDKPayeePubKey* operator ->() { return &self; }
+	const LDKPayeePubKey* operator &() const { return &self; }
+	const LDKPayeePubKey* operator ->() const { return &self; }
+};
+class ExpiryTime {
+private:
+	LDKExpiryTime self;
+public:
+	ExpiryTime(const ExpiryTime&) = delete;
+	ExpiryTime(ExpiryTime&& o) : self(o.self) { memset(&o, 0, sizeof(ExpiryTime)); }
+	ExpiryTime(LDKExpiryTime&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpiryTime)); }
+	operator LDKExpiryTime() && { LDKExpiryTime res = self; memset(&self, 0, sizeof(LDKExpiryTime)); return res; }
+	~ExpiryTime() { ExpiryTime_free(self); }
+	ExpiryTime& operator=(ExpiryTime&& o) { ExpiryTime_free(self); self = o.self; memset(&o, 0, sizeof(ExpiryTime)); return *this; }
+	LDKExpiryTime* operator &() { return &self; }
+	LDKExpiryTime* operator ->() { return &self; }
+	const LDKExpiryTime* operator &() const { return &self; }
+	const LDKExpiryTime* operator ->() const { return &self; }
+};
+class MinFinalCltvExpiry {
+private:
+	LDKMinFinalCltvExpiry self;
+public:
+	MinFinalCltvExpiry(const MinFinalCltvExpiry&) = delete;
+	MinFinalCltvExpiry(MinFinalCltvExpiry&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiry)); }
+	MinFinalCltvExpiry(LDKMinFinalCltvExpiry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiry)); }
+	operator LDKMinFinalCltvExpiry() && { LDKMinFinalCltvExpiry res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiry)); return res; }
+	~MinFinalCltvExpiry() { MinFinalCltvExpiry_free(self); }
+	MinFinalCltvExpiry& operator=(MinFinalCltvExpiry&& o) { MinFinalCltvExpiry_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiry)); return *this; }
+	LDKMinFinalCltvExpiry* operator &() { return &self; }
+	LDKMinFinalCltvExpiry* operator ->() { return &self; }
+	const LDKMinFinalCltvExpiry* operator &() const { return &self; }
+	const LDKMinFinalCltvExpiry* operator ->() const { return &self; }
+};
+class Fallback {
+private:
+	LDKFallback self;
+public:
+	Fallback(const Fallback&) = delete;
+	Fallback(Fallback&& o) : self(o.self) { memset(&o, 0, sizeof(Fallback)); }
+	Fallback(LDKFallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFallback)); }
+	operator LDKFallback() && { LDKFallback res = self; memset(&self, 0, sizeof(LDKFallback)); return res; }
+	~Fallback() { Fallback_free(self); }
+	Fallback& operator=(Fallback&& o) { Fallback_free(self); self = o.self; memset(&o, 0, sizeof(Fallback)); return *this; }
+	LDKFallback* operator &() { return &self; }
+	LDKFallback* operator ->() { return &self; }
+	const LDKFallback* operator &() const { return &self; }
+	const LDKFallback* operator ->() const { return &self; }
+};
+class InvoiceSignature {
+private:
+	LDKInvoiceSignature self;
+public:
+	InvoiceSignature(const InvoiceSignature&) = delete;
+	InvoiceSignature(InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceSignature)); }
+	InvoiceSignature(LDKInvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceSignature)); }
+	operator LDKInvoiceSignature() && { LDKInvoiceSignature res = self; memset(&self, 0, sizeof(LDKInvoiceSignature)); return res; }
+	~InvoiceSignature() { InvoiceSignature_free(self); }
+	InvoiceSignature& operator=(InvoiceSignature&& o) { InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceSignature)); return *this; }
+	LDKInvoiceSignature* operator &() { return &self; }
+	LDKInvoiceSignature* operator ->() { return &self; }
+	const LDKInvoiceSignature* operator &() const { return &self; }
+	const LDKInvoiceSignature* operator ->() const { return &self; }
+};
+class RouteHint {
+private:
+	LDKRouteHint self;
+public:
+	RouteHint(const RouteHint&) = delete;
+	RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
+	RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
+	operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
+	~RouteHint() { RouteHint_free(self); }
+	RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
+	LDKRouteHint* operator &() { return &self; }
+	LDKRouteHint* operator ->() { return &self; }
+	const LDKRouteHint* operator &() const { return &self; }
+	const LDKRouteHint* operator ->() const { return &self; }
+};
+class CreationError {
+private:
+	LDKCreationError self;
+public:
+	CreationError(const CreationError&) = delete;
+	CreationError(CreationError&& o) : self(o.self) { memset(&o, 0, sizeof(CreationError)); }
+	CreationError(LDKCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCreationError)); }
+	operator LDKCreationError() && { LDKCreationError res = self; memset(&self, 0, sizeof(LDKCreationError)); return res; }
+	CreationError& operator=(CreationError&& o) { self = o.self; memset(&o, 0, sizeof(CreationError)); return *this; }
+	LDKCreationError* operator &() { return &self; }
+	LDKCreationError* operator ->() { return &self; }
+	const LDKCreationError* operator &() const { return &self; }
+	const LDKCreationError* operator ->() const { return &self; }
+};
+class SemanticError {
+private:
+	LDKSemanticError self;
+public:
+	SemanticError(const SemanticError&) = delete;
+	SemanticError(SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(SemanticError)); }
+	SemanticError(LDKSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSemanticError)); }
+	operator LDKSemanticError() && { LDKSemanticError res = self; memset(&self, 0, sizeof(LDKSemanticError)); return res; }
+	SemanticError& operator=(SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(SemanticError)); return *this; }
+	LDKSemanticError* operator &() { return &self; }
+	LDKSemanticError* operator ->() { return &self; }
+	const LDKSemanticError* operator &() const { return &self; }
+	const LDKSemanticError* operator ->() const { return &self; }
+};
+class SignOrCreationError {
+private:
+	LDKSignOrCreationError self;
+public:
+	SignOrCreationError(const SignOrCreationError&) = delete;
+	SignOrCreationError(SignOrCreationError&& o) : self(o.self) { memset(&o, 0, sizeof(SignOrCreationError)); }
+	SignOrCreationError(LDKSignOrCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignOrCreationError)); }
+	operator LDKSignOrCreationError() && { LDKSignOrCreationError res = self; memset(&self, 0, sizeof(LDKSignOrCreationError)); return res; }
+	~SignOrCreationError() { SignOrCreationError_free(self); }
+	SignOrCreationError& operator=(SignOrCreationError&& o) { SignOrCreationError_free(self); self = o.self; memset(&o, 0, sizeof(SignOrCreationError)); return *this; }
+	LDKSignOrCreationError* operator &() { return &self; }
+	LDKSignOrCreationError* operator ->() { return &self; }
+	const LDKSignOrCreationError* operator &() const { return &self; }
+	const LDKSignOrCreationError* operator ->() const { return &self; }
+};
+class ChannelMonitorUpdate {
+private:
+	LDKChannelMonitorUpdate self;
+public:
+	ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
+	ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
+	ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
+	operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
+	~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
+	ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
+	LDKChannelMonitorUpdate* operator &() { return &self; }
+	LDKChannelMonitorUpdate* operator ->() { return &self; }
+	const LDKChannelMonitorUpdate* operator &() const { return &self; }
+	const LDKChannelMonitorUpdate* operator ->() const { return &self; }
+};
+class ChannelMonitorUpdateErr {
+private:
+	LDKChannelMonitorUpdateErr self;
+public:
+	ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete;
+	ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); }
+	ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); }
+	operator LDKChannelMonitorUpdateErr() && { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; }
+	ChannelMonitorUpdateErr& operator=(ChannelMonitorUpdateErr&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); return *this; }
+	LDKChannelMonitorUpdateErr* operator &() { return &self; }
+	LDKChannelMonitorUpdateErr* operator ->() { return &self; }
+	const LDKChannelMonitorUpdateErr* operator &() const { return &self; }
+	const LDKChannelMonitorUpdateErr* operator ->() const { return &self; }
+};
+class MonitorUpdateError {
+private:
+	LDKMonitorUpdateError self;
+public:
+	MonitorUpdateError(const MonitorUpdateError&) = delete;
+	MonitorUpdateError(MonitorUpdateError&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateError)); }
+	MonitorUpdateError(LDKMonitorUpdateError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateError)); }
+	operator LDKMonitorUpdateError() && { LDKMonitorUpdateError res = self; memset(&self, 0, sizeof(LDKMonitorUpdateError)); return res; }
+	~MonitorUpdateError() { MonitorUpdateError_free(self); }
+	MonitorUpdateError& operator=(MonitorUpdateError&& o) { MonitorUpdateError_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateError)); return *this; }
+	LDKMonitorUpdateError* operator &() { return &self; }
+	LDKMonitorUpdateError* operator ->() { return &self; }
+	const LDKMonitorUpdateError* operator &() const { return &self; }
+	const LDKMonitorUpdateError* operator ->() const { return &self; }
+};
+class MonitorEvent {
+private:
+	LDKMonitorEvent self;
+public:
+	MonitorEvent(const MonitorEvent&) = delete;
+	MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
+	MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
+	operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
+	~MonitorEvent() { MonitorEvent_free(self); }
+	MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
+	LDKMonitorEvent* operator &() { return &self; }
+	LDKMonitorEvent* operator ->() { return &self; }
+	const LDKMonitorEvent* operator &() const { return &self; }
+	const LDKMonitorEvent* operator ->() const { return &self; }
+};
+class HTLCUpdate {
+private:
+	LDKHTLCUpdate self;
+public:
+	HTLCUpdate(const HTLCUpdate&) = delete;
+	HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
+	HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
+	operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
+	~HTLCUpdate() { HTLCUpdate_free(self); }
+	HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
+	LDKHTLCUpdate* operator &() { return &self; }
+	LDKHTLCUpdate* operator ->() { return &self; }
+	const LDKHTLCUpdate* operator &() const { return &self; }
+	const LDKHTLCUpdate* operator ->() const { return &self; }
+};
+class ChannelMonitor {
+private:
+	LDKChannelMonitor self;
+public:
+	ChannelMonitor(const ChannelMonitor&) = delete;
+	ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
+	ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
+	operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
+	~ChannelMonitor() { ChannelMonitor_free(self); }
+	ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
+	LDKChannelMonitor* operator &() { return &self; }
+	LDKChannelMonitor* operator ->() { return &self; }
+	const LDKChannelMonitor* operator &() const { return &self; }
+	const LDKChannelMonitor* operator ->() const { return &self; }
+};
+class Persist {
+private:
+	LDKPersist self;
+public:
+	Persist(const Persist&) = delete;
+	Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
+	Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
+	operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
+	~Persist() { Persist_free(self); }
+	Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
+	LDKPersist* operator &() { return &self; }
+	LDKPersist* operator ->() { return &self; }
+	const LDKPersist* operator &() const { return &self; }
+	const LDKPersist* operator ->() const { return &self; }
+};
+class RouteHop {
+private:
+	LDKRouteHop self;
+public:
+	RouteHop(const RouteHop&) = delete;
+	RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
+	RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
+	operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
+	~RouteHop() { RouteHop_free(self); }
+	RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
+	LDKRouteHop* operator &() { return &self; }
+	LDKRouteHop* operator ->() { return &self; }
+	const LDKRouteHop* operator &() const { return &self; }
+	const LDKRouteHop* operator ->() const { return &self; }
+};
+class Route {
+private:
+	LDKRoute self;
+public:
+	Route(const Route&) = delete;
+	Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
+	Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
+	operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
+	~Route() { Route_free(self); }
+	Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
+	LDKRoute* operator &() { return &self; }
+	LDKRoute* operator ->() { return &self; }
+	const LDKRoute* operator &() const { return &self; }
+	const LDKRoute* operator ->() const { return &self; }
+};
+class RouteHintHop {
+private:
+	LDKRouteHintHop self;
+public:
+	RouteHintHop(const RouteHintHop&) = delete;
+	RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
+	RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
+	operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
+	~RouteHintHop() { RouteHintHop_free(self); }
+	RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
+	LDKRouteHintHop* operator &() { return &self; }
+	LDKRouteHintHop* operator ->() { return &self; }
+	const LDKRouteHintHop* operator &() const { return &self; }
+	const LDKRouteHintHop* operator ->() const { return &self; }
+};
 class IgnoringMessageHandler {
 private:
 	LDKIgnoringMessageHandler self;
@@ -255,125 +745,213 @@ public:
 	const LDKPeerManager* operator &() const { return &self; }
 	const LDKPeerManager* operator ->() const { return &self; }
 };
-class InitFeatures {
+class BroadcasterInterface {
 private:
-	LDKInitFeatures self;
+	LDKBroadcasterInterface self;
 public:
-	InitFeatures(const InitFeatures&) = delete;
-	InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
-	InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
-	operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
-	~InitFeatures() { InitFeatures_free(self); }
-	InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
-	LDKInitFeatures* operator &() { return &self; }
-	LDKInitFeatures* operator ->() { return &self; }
-	const LDKInitFeatures* operator &() const { return &self; }
-	const LDKInitFeatures* operator ->() const { return &self; }
+	BroadcasterInterface(const BroadcasterInterface&) = delete;
+	BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
+	BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
+	operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
+	~BroadcasterInterface() { BroadcasterInterface_free(self); }
+	BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
+	LDKBroadcasterInterface* operator &() { return &self; }
+	LDKBroadcasterInterface* operator ->() { return &self; }
+	const LDKBroadcasterInterface* operator &() const { return &self; }
+	const LDKBroadcasterInterface* operator ->() const { return &self; }
 };
-class NodeFeatures {
+class ConfirmationTarget {
 private:
-	LDKNodeFeatures self;
+	LDKConfirmationTarget self;
 public:
-	NodeFeatures(const NodeFeatures&) = delete;
-	NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
-	NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
-	operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
-	~NodeFeatures() { NodeFeatures_free(self); }
-	NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
-	LDKNodeFeatures* operator &() { return &self; }
-	LDKNodeFeatures* operator ->() { return &self; }
-	const LDKNodeFeatures* operator &() const { return &self; }
-	const LDKNodeFeatures* operator ->() const { return &self; }
+	ConfirmationTarget(const ConfirmationTarget&) = delete;
+	ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
+	ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
+	operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
+	ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
+	LDKConfirmationTarget* operator &() { return &self; }
+	LDKConfirmationTarget* operator ->() { return &self; }
+	const LDKConfirmationTarget* operator &() const { return &self; }
+	const LDKConfirmationTarget* operator ->() const { return &self; }
 };
-class ChannelFeatures {
+class FeeEstimator {
 private:
-	LDKChannelFeatures self;
+	LDKFeeEstimator self;
 public:
-	ChannelFeatures(const ChannelFeatures&) = delete;
-	ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
-	ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
-	operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
-	~ChannelFeatures() { ChannelFeatures_free(self); }
-	ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
-	LDKChannelFeatures* operator &() { return &self; }
-	LDKChannelFeatures* operator ->() { return &self; }
-	const LDKChannelFeatures* operator &() const { return &self; }
-	const LDKChannelFeatures* operator ->() const { return &self; }
+	FeeEstimator(const FeeEstimator&) = delete;
+	FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
+	FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
+	operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
+	~FeeEstimator() { FeeEstimator_free(self); }
+	FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
+	LDKFeeEstimator* operator &() { return &self; }
+	LDKFeeEstimator* operator ->() { return &self; }
+	const LDKFeeEstimator* operator &() const { return &self; }
+	const LDKFeeEstimator* operator ->() const { return &self; }
 };
-class InvoiceFeatures {
+class AccessError {
 private:
-	LDKInvoiceFeatures self;
+	LDKAccessError self;
 public:
-	InvoiceFeatures(const InvoiceFeatures&) = delete;
-	InvoiceFeatures(InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceFeatures)); }
-	InvoiceFeatures(LDKInvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceFeatures)); }
-	operator LDKInvoiceFeatures() && { LDKInvoiceFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceFeatures)); return res; }
-	~InvoiceFeatures() { InvoiceFeatures_free(self); }
-	InvoiceFeatures& operator=(InvoiceFeatures&& o) { InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceFeatures)); return *this; }
-	LDKInvoiceFeatures* operator &() { return &self; }
-	LDKInvoiceFeatures* operator ->() { return &self; }
-	const LDKInvoiceFeatures* operator &() const { return &self; }
-	const LDKInvoiceFeatures* operator ->() const { return &self; }
+	AccessError(const AccessError&) = delete;
+	AccessError(AccessError&& o) : self(o.self) { memset(&o, 0, sizeof(AccessError)); }
+	AccessError(LDKAccessError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccessError)); }
+	operator LDKAccessError() && { LDKAccessError res = self; memset(&self, 0, sizeof(LDKAccessError)); return res; }
+	AccessError& operator=(AccessError&& o) { self = o.self; memset(&o, 0, sizeof(AccessError)); return *this; }
+	LDKAccessError* operator &() { return &self; }
+	LDKAccessError* operator ->() { return &self; }
+	const LDKAccessError* operator &() const { return &self; }
+	const LDKAccessError* operator ->() const { return &self; }
 };
-class ChannelHandshakeConfig {
+class Access {
 private:
-	LDKChannelHandshakeConfig self;
+	LDKAccess self;
 public:
-	ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
-	ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
-	ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
-	operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
-	~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
-	ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
-	LDKChannelHandshakeConfig* operator &() { return &self; }
-	LDKChannelHandshakeConfig* operator ->() { return &self; }
-	const LDKChannelHandshakeConfig* operator &() const { return &self; }
-	const LDKChannelHandshakeConfig* operator ->() const { return &self; }
+	Access(const Access&) = delete;
+	Access(Access&& o) : self(o.self) { memset(&o, 0, sizeof(Access)); }
+	Access(LDKAccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccess)); }
+	operator LDKAccess() && { LDKAccess res = self; memset(&self, 0, sizeof(LDKAccess)); return res; }
+	~Access() { Access_free(self); }
+	Access& operator=(Access&& o) { Access_free(self); self = o.self; memset(&o, 0, sizeof(Access)); return *this; }
+	LDKAccess* operator &() { return &self; }
+	LDKAccess* operator ->() { return &self; }
+	const LDKAccess* operator &() const { return &self; }
+	const LDKAccess* operator ->() const { return &self; }
 };
-class ChannelHandshakeLimits {
+class Listen {
 private:
-	LDKChannelHandshakeLimits self;
+	LDKListen self;
 public:
-	ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
-	ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
-	ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
-	operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
-	~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
-	ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
-	LDKChannelHandshakeLimits* operator &() { return &self; }
-	LDKChannelHandshakeLimits* operator ->() { return &self; }
-	const LDKChannelHandshakeLimits* operator &() const { return &self; }
-	const LDKChannelHandshakeLimits* operator ->() const { return &self; }
+	Listen(const Listen&) = delete;
+	Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
+	Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
+	operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
+	~Listen() { Listen_free(self); }
+	Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
+	LDKListen* operator &() { return &self; }
+	LDKListen* operator ->() { return &self; }
+	const LDKListen* operator &() const { return &self; }
+	const LDKListen* operator ->() const { return &self; }
 };
-class ChannelConfig {
+class Confirm {
 private:
-	LDKChannelConfig self;
+	LDKConfirm self;
 public:
-	ChannelConfig(const ChannelConfig&) = delete;
-	ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
-	ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
-	operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
-	~ChannelConfig() { ChannelConfig_free(self); }
-	ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
-	LDKChannelConfig* operator &() { return &self; }
-	LDKChannelConfig* operator ->() { return &self; }
-	const LDKChannelConfig* operator &() const { return &self; }
-	const LDKChannelConfig* operator ->() const { return &self; }
+	Confirm(const Confirm&) = delete;
+	Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
+	Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
+	operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
+	~Confirm() { Confirm_free(self); }
+	Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
+	LDKConfirm* operator &() { return &self; }
+	LDKConfirm* operator ->() { return &self; }
+	const LDKConfirm* operator &() const { return &self; }
+	const LDKConfirm* operator ->() const { return &self; }
 };
-class UserConfig {
+class Watch {
 private:
-	LDKUserConfig self;
+	LDKWatch self;
 public:
-	UserConfig(const UserConfig&) = delete;
-	UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
-	UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
-	operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
-	~UserConfig() { UserConfig_free(self); }
-	UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
-	LDKUserConfig* operator &() { return &self; }
-	LDKUserConfig* operator ->() { return &self; }
-	const LDKUserConfig* operator &() const { return &self; }
-	const LDKUserConfig* operator ->() const { return &self; }
+	Watch(const Watch&) = delete;
+	Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
+	Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
+	operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
+	~Watch() { Watch_free(self); }
+	Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
+	LDKWatch* operator &() { return &self; }
+	LDKWatch* operator ->() { return &self; }
+	const LDKWatch* operator &() const { return &self; }
+	const LDKWatch* operator ->() const { return &self; }
+};
+class Filter {
+private:
+	LDKFilter self;
+public:
+	Filter(const Filter&) = delete;
+	Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
+	Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
+	operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
+	~Filter() { Filter_free(self); }
+	Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
+	LDKFilter* operator &() { return &self; }
+	LDKFilter* operator ->() { return &self; }
+	const LDKFilter* operator &() const { return &self; }
+	const LDKFilter* operator ->() const { return &self; }
+};
+class WatchedOutput {
+private:
+	LDKWatchedOutput self;
+public:
+	WatchedOutput(const WatchedOutput&) = delete;
+	WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
+	WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
+	operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
+	~WatchedOutput() { WatchedOutput_free(self); }
+	WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
+	LDKWatchedOutput* operator &() { return &self; }
+	LDKWatchedOutput* operator ->() { return &self; }
+	const LDKWatchedOutput* operator &() const { return &self; }
+	const LDKWatchedOutput* operator ->() const { return &self; }
+};
+class Event {
+private:
+	LDKEvent self;
+public:
+	Event(const Event&) = delete;
+	Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
+	Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
+	operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
+	~Event() { Event_free(self); }
+	Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
+	LDKEvent* operator &() { return &self; }
+	LDKEvent* operator ->() { return &self; }
+	const LDKEvent* operator &() const { return &self; }
+	const LDKEvent* operator ->() const { return &self; }
+};
+class MessageSendEvent {
+private:
+	LDKMessageSendEvent self;
+public:
+	MessageSendEvent(const MessageSendEvent&) = delete;
+	MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
+	MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
+	operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
+	~MessageSendEvent() { MessageSendEvent_free(self); }
+	MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
+	LDKMessageSendEvent* operator &() { return &self; }
+	LDKMessageSendEvent* operator ->() { return &self; }
+	const LDKMessageSendEvent* operator &() const { return &self; }
+	const LDKMessageSendEvent* operator ->() const { return &self; }
+};
+class MessageSendEventsProvider {
+private:
+	LDKMessageSendEventsProvider self;
+public:
+	MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
+	MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
+	MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
+	operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
+	~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
+	MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
+	LDKMessageSendEventsProvider* operator &() { return &self; }
+	LDKMessageSendEventsProvider* operator ->() { return &self; }
+	const LDKMessageSendEventsProvider* operator &() const { return &self; }
+	const LDKMessageSendEventsProvider* operator ->() const { return &self; }
+};
+class EventsProvider {
+private:
+	LDKEventsProvider self;
+public:
+	EventsProvider(const EventsProvider&) = delete;
+	EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
+	EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
+	operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
+	~EventsProvider() { EventsProvider_free(self); }
+	EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
+	LDKEventsProvider* operator &() { return &self; }
+	LDKEventsProvider* operator ->() { return &self; }
+	const LDKEventsProvider* operator &() const { return &self; }
+	const LDKEventsProvider* operator ->() const { return &self; }
 };
 class NetworkGraph {
 private:
@@ -495,499 +1073,742 @@ public:
 	const LDKNodeInfo* operator &() const { return &self; }
 	const LDKNodeInfo* operator ->() const { return &self; }
 };
-class Level {
+class InitFeatures {
 private:
-	LDKLevel self;
+	LDKInitFeatures self;
 public:
-	Level(const Level&) = delete;
-	Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
-	Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
-	operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
-	Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
-	LDKLevel* operator &() { return &self; }
-	LDKLevel* operator ->() { return &self; }
-	const LDKLevel* operator &() const { return &self; }
-	const LDKLevel* operator ->() const { return &self; }
-};
-class Logger {
+	InitFeatures(const InitFeatures&) = delete;
+	InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
+	InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
+	operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
+	~InitFeatures() { InitFeatures_free(self); }
+	InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
+	LDKInitFeatures* operator &() { return &self; }
+	LDKInitFeatures* operator ->() { return &self; }
+	const LDKInitFeatures* operator &() const { return &self; }
+	const LDKInitFeatures* operator ->() const { return &self; }
+};
+class NodeFeatures {
 private:
-	LDKLogger self;
+	LDKNodeFeatures self;
 public:
-	Logger(const Logger&) = delete;
-	Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
-	Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
-	operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
-	~Logger() { Logger_free(self); }
-	Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
-	LDKLogger* operator &() { return &self; }
-	LDKLogger* operator ->() { return &self; }
-	const LDKLogger* operator &() const { return &self; }
-	const LDKLogger* operator ->() const { return &self; }
+	NodeFeatures(const NodeFeatures&) = delete;
+	NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
+	NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
+	operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
+	~NodeFeatures() { NodeFeatures_free(self); }
+	NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
+	LDKNodeFeatures* operator &() { return &self; }
+	LDKNodeFeatures* operator ->() { return &self; }
+	const LDKNodeFeatures* operator &() const { return &self; }
+	const LDKNodeFeatures* operator ->() const { return &self; }
 };
-class ChainMonitor {
+class ChannelFeatures {
 private:
-	LDKChainMonitor self;
+	LDKChannelFeatures self;
 public:
-	ChainMonitor(const ChainMonitor&) = delete;
-	ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
-	ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
-	operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
-	~ChainMonitor() { ChainMonitor_free(self); }
-	ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
-	LDKChainMonitor* operator &() { return &self; }
-	LDKChainMonitor* operator ->() { return &self; }
-	const LDKChainMonitor* operator &() const { return &self; }
-	const LDKChainMonitor* operator ->() const { return &self; }
+	ChannelFeatures(const ChannelFeatures&) = delete;
+	ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
+	ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
+	operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
+	~ChannelFeatures() { ChannelFeatures_free(self); }
+	ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
+	LDKChannelFeatures* operator &() { return &self; }
+	LDKChannelFeatures* operator ->() { return &self; }
+	const LDKChannelFeatures* operator &() const { return &self; }
+	const LDKChannelFeatures* operator ->() const { return &self; }
 };
-class OutPoint {
+class InvoiceFeatures {
 private:
-	LDKOutPoint self;
+	LDKInvoiceFeatures self;
 public:
-	OutPoint(const OutPoint&) = delete;
-	OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
-	OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
-	operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
-	~OutPoint() { OutPoint_free(self); }
-	OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
-	LDKOutPoint* operator &() { return &self; }
-	LDKOutPoint* operator ->() { return &self; }
-	const LDKOutPoint* operator &() const { return &self; }
-	const LDKOutPoint* operator ->() const { return &self; }
+	InvoiceFeatures(const InvoiceFeatures&) = delete;
+	InvoiceFeatures(InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceFeatures)); }
+	InvoiceFeatures(LDKInvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceFeatures)); }
+	operator LDKInvoiceFeatures() && { LDKInvoiceFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceFeatures)); return res; }
+	~InvoiceFeatures() { InvoiceFeatures_free(self); }
+	InvoiceFeatures& operator=(InvoiceFeatures&& o) { InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceFeatures)); return *this; }
+	LDKInvoiceFeatures* operator &() { return &self; }
+	LDKInvoiceFeatures* operator ->() { return &self; }
+	const LDKInvoiceFeatures* operator &() const { return &self; }
+	const LDKInvoiceFeatures* operator ->() const { return &self; }
 };
-class ChannelMonitorUpdate {
+class DecodeError {
 private:
-	LDKChannelMonitorUpdate self;
+	LDKDecodeError self;
 public:
-	ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
-	ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
-	ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
-	operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
-	~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
-	ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
-	LDKChannelMonitorUpdate* operator &() { return &self; }
-	LDKChannelMonitorUpdate* operator ->() { return &self; }
-	const LDKChannelMonitorUpdate* operator &() const { return &self; }
-	const LDKChannelMonitorUpdate* operator ->() const { return &self; }
+	DecodeError(const DecodeError&) = delete;
+	DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
+	DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
+	operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
+	~DecodeError() { DecodeError_free(self); }
+	DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
+	LDKDecodeError* operator &() { return &self; }
+	LDKDecodeError* operator ->() { return &self; }
+	const LDKDecodeError* operator &() const { return &self; }
+	const LDKDecodeError* operator ->() const { return &self; }
 };
-class ChannelMonitorUpdateErr {
+class Init {
 private:
-	LDKChannelMonitorUpdateErr self;
+	LDKInit self;
 public:
-	ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete;
-	ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); }
-	ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); }
-	operator LDKChannelMonitorUpdateErr() && { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; }
-	ChannelMonitorUpdateErr& operator=(ChannelMonitorUpdateErr&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); return *this; }
-	LDKChannelMonitorUpdateErr* operator &() { return &self; }
-	LDKChannelMonitorUpdateErr* operator ->() { return &self; }
-	const LDKChannelMonitorUpdateErr* operator &() const { return &self; }
-	const LDKChannelMonitorUpdateErr* operator ->() const { return &self; }
+	Init(const Init&) = delete;
+	Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
+	Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
+	operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
+	~Init() { Init_free(self); }
+	Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
+	LDKInit* operator &() { return &self; }
+	LDKInit* operator ->() { return &self; }
+	const LDKInit* operator &() const { return &self; }
+	const LDKInit* operator ->() const { return &self; }
 };
-class MonitorUpdateError {
+class ErrorMessage {
 private:
-	LDKMonitorUpdateError self;
+	LDKErrorMessage self;
 public:
-	MonitorUpdateError(const MonitorUpdateError&) = delete;
-	MonitorUpdateError(MonitorUpdateError&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateError)); }
-	MonitorUpdateError(LDKMonitorUpdateError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateError)); }
-	operator LDKMonitorUpdateError() && { LDKMonitorUpdateError res = self; memset(&self, 0, sizeof(LDKMonitorUpdateError)); return res; }
-	~MonitorUpdateError() { MonitorUpdateError_free(self); }
-	MonitorUpdateError& operator=(MonitorUpdateError&& o) { MonitorUpdateError_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateError)); return *this; }
-	LDKMonitorUpdateError* operator &() { return &self; }
-	LDKMonitorUpdateError* operator ->() { return &self; }
-	const LDKMonitorUpdateError* operator &() const { return &self; }
-	const LDKMonitorUpdateError* operator ->() const { return &self; }
+	ErrorMessage(const ErrorMessage&) = delete;
+	ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
+	ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
+	operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
+	~ErrorMessage() { ErrorMessage_free(self); }
+	ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
+	LDKErrorMessage* operator &() { return &self; }
+	LDKErrorMessage* operator ->() { return &self; }
+	const LDKErrorMessage* operator &() const { return &self; }
+	const LDKErrorMessage* operator ->() const { return &self; }
 };
-class MonitorEvent {
+class Ping {
 private:
-	LDKMonitorEvent self;
+	LDKPing self;
 public:
-	MonitorEvent(const MonitorEvent&) = delete;
-	MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
-	MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
-	operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
-	~MonitorEvent() { MonitorEvent_free(self); }
-	MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
-	LDKMonitorEvent* operator &() { return &self; }
-	LDKMonitorEvent* operator ->() { return &self; }
-	const LDKMonitorEvent* operator &() const { return &self; }
-	const LDKMonitorEvent* operator ->() const { return &self; }
+	Ping(const Ping&) = delete;
+	Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
+	Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
+	operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
+	~Ping() { Ping_free(self); }
+	Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
+	LDKPing* operator &() { return &self; }
+	LDKPing* operator ->() { return &self; }
+	const LDKPing* operator &() const { return &self; }
+	const LDKPing* operator ->() const { return &self; }
 };
-class HTLCUpdate {
+class Pong {
 private:
-	LDKHTLCUpdate self;
+	LDKPong self;
 public:
-	HTLCUpdate(const HTLCUpdate&) = delete;
-	HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
-	HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
-	operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
-	~HTLCUpdate() { HTLCUpdate_free(self); }
-	HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
-	LDKHTLCUpdate* operator &() { return &self; }
-	LDKHTLCUpdate* operator ->() { return &self; }
-	const LDKHTLCUpdate* operator &() const { return &self; }
-	const LDKHTLCUpdate* operator ->() const { return &self; }
+	Pong(const Pong&) = delete;
+	Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
+	Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
+	operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
+	~Pong() { Pong_free(self); }
+	Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
+	LDKPong* operator &() { return &self; }
+	LDKPong* operator ->() { return &self; }
+	const LDKPong* operator &() const { return &self; }
+	const LDKPong* operator ->() const { return &self; }
 };
-class ChannelMonitor {
+class OpenChannel {
 private:
-	LDKChannelMonitor self;
+	LDKOpenChannel self;
 public:
-	ChannelMonitor(const ChannelMonitor&) = delete;
-	ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
-	ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
-	operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
-	~ChannelMonitor() { ChannelMonitor_free(self); }
-	ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
-	LDKChannelMonitor* operator &() { return &self; }
-	LDKChannelMonitor* operator ->() { return &self; }
-	const LDKChannelMonitor* operator &() const { return &self; }
-	const LDKChannelMonitor* operator ->() const { return &self; }
+	OpenChannel(const OpenChannel&) = delete;
+	OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
+	OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
+	operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
+	~OpenChannel() { OpenChannel_free(self); }
+	OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
+	LDKOpenChannel* operator &() { return &self; }
+	LDKOpenChannel* operator ->() { return &self; }
+	const LDKOpenChannel* operator &() const { return &self; }
+	const LDKOpenChannel* operator ->() const { return &self; }
 };
-class Persist {
+class AcceptChannel {
 private:
-	LDKPersist self;
+	LDKAcceptChannel self;
 public:
-	Persist(const Persist&) = delete;
-	Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
-	Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
-	operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
-	~Persist() { Persist_free(self); }
-	Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
-	LDKPersist* operator &() { return &self; }
-	LDKPersist* operator ->() { return &self; }
-	const LDKPersist* operator &() const { return &self; }
-	const LDKPersist* operator ->() const { return &self; }
+	AcceptChannel(const AcceptChannel&) = delete;
+	AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
+	AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
+	operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
+	~AcceptChannel() { AcceptChannel_free(self); }
+	AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
+	LDKAcceptChannel* operator &() { return &self; }
+	LDKAcceptChannel* operator ->() { return &self; }
+	const LDKAcceptChannel* operator &() const { return &self; }
+	const LDKAcceptChannel* operator ->() const { return &self; }
 };
-class Event {
+class FundingCreated {
 private:
-	LDKEvent self;
+	LDKFundingCreated self;
 public:
-	Event(const Event&) = delete;
-	Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
-	Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
-	operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
-	~Event() { Event_free(self); }
-	Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
-	LDKEvent* operator &() { return &self; }
-	LDKEvent* operator ->() { return &self; }
-	const LDKEvent* operator &() const { return &self; }
-	const LDKEvent* operator ->() const { return &self; }
+	FundingCreated(const FundingCreated&) = delete;
+	FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
+	FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
+	operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
+	~FundingCreated() { FundingCreated_free(self); }
+	FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
+	LDKFundingCreated* operator &() { return &self; }
+	LDKFundingCreated* operator ->() { return &self; }
+	const LDKFundingCreated* operator &() const { return &self; }
+	const LDKFundingCreated* operator ->() const { return &self; }
 };
-class MessageSendEvent {
+class FundingSigned {
 private:
-	LDKMessageSendEvent self;
+	LDKFundingSigned self;
 public:
-	MessageSendEvent(const MessageSendEvent&) = delete;
-	MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
-	MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
-	operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
-	~MessageSendEvent() { MessageSendEvent_free(self); }
-	MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
-	LDKMessageSendEvent* operator &() { return &self; }
-	LDKMessageSendEvent* operator ->() { return &self; }
-	const LDKMessageSendEvent* operator &() const { return &self; }
-	const LDKMessageSendEvent* operator ->() const { return &self; }
+	FundingSigned(const FundingSigned&) = delete;
+	FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
+	FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
+	operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
+	~FundingSigned() { FundingSigned_free(self); }
+	FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
+	LDKFundingSigned* operator &() { return &self; }
+	LDKFundingSigned* operator ->() { return &self; }
+	const LDKFundingSigned* operator &() const { return &self; }
+	const LDKFundingSigned* operator ->() const { return &self; }
 };
-class MessageSendEventsProvider {
+class FundingLocked {
 private:
-	LDKMessageSendEventsProvider self;
+	LDKFundingLocked self;
 public:
-	MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
-	MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
-	MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
-	operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
-	~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
-	MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
-	LDKMessageSendEventsProvider* operator &() { return &self; }
-	LDKMessageSendEventsProvider* operator ->() { return &self; }
-	const LDKMessageSendEventsProvider* operator &() const { return &self; }
-	const LDKMessageSendEventsProvider* operator ->() const { return &self; }
+	FundingLocked(const FundingLocked&) = delete;
+	FundingLocked(FundingLocked&& o) : self(o.self) { memset(&o, 0, sizeof(FundingLocked)); }
+	FundingLocked(LDKFundingLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingLocked)); }
+	operator LDKFundingLocked() && { LDKFundingLocked res = self; memset(&self, 0, sizeof(LDKFundingLocked)); return res; }
+	~FundingLocked() { FundingLocked_free(self); }
+	FundingLocked& operator=(FundingLocked&& o) { FundingLocked_free(self); self = o.self; memset(&o, 0, sizeof(FundingLocked)); return *this; }
+	LDKFundingLocked* operator &() { return &self; }
+	LDKFundingLocked* operator ->() { return &self; }
+	const LDKFundingLocked* operator &() const { return &self; }
+	const LDKFundingLocked* operator ->() const { return &self; }
 };
-class EventsProvider {
+class Shutdown {
 private:
-	LDKEventsProvider self;
+	LDKShutdown self;
 public:
-	EventsProvider(const EventsProvider&) = delete;
-	EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
-	EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
-	operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
-	~EventsProvider() { EventsProvider_free(self); }
-	EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
-	LDKEventsProvider* operator &() { return &self; }
-	LDKEventsProvider* operator ->() { return &self; }
-	const LDKEventsProvider* operator &() const { return &self; }
-	const LDKEventsProvider* operator ->() const { return &self; }
+	Shutdown(const Shutdown&) = delete;
+	Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
+	Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
+	operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
+	~Shutdown() { Shutdown_free(self); }
+	Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
+	LDKShutdown* operator &() { return &self; }
+	LDKShutdown* operator ->() { return &self; }
+	const LDKShutdown* operator &() const { return &self; }
+	const LDKShutdown* operator ->() const { return &self; }
 };
-class AccessError {
+class ClosingSigned {
 private:
-	LDKAccessError self;
+	LDKClosingSigned self;
 public:
-	AccessError(const AccessError&) = delete;
-	AccessError(AccessError&& o) : self(o.self) { memset(&o, 0, sizeof(AccessError)); }
-	AccessError(LDKAccessError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccessError)); }
-	operator LDKAccessError() && { LDKAccessError res = self; memset(&self, 0, sizeof(LDKAccessError)); return res; }
-	AccessError& operator=(AccessError&& o) { self = o.self; memset(&o, 0, sizeof(AccessError)); return *this; }
-	LDKAccessError* operator &() { return &self; }
-	LDKAccessError* operator ->() { return &self; }
-	const LDKAccessError* operator &() const { return &self; }
-	const LDKAccessError* operator ->() const { return &self; }
+	ClosingSigned(const ClosingSigned&) = delete;
+	ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
+	ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
+	operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
+	~ClosingSigned() { ClosingSigned_free(self); }
+	ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
+	LDKClosingSigned* operator &() { return &self; }
+	LDKClosingSigned* operator ->() { return &self; }
+	const LDKClosingSigned* operator &() const { return &self; }
+	const LDKClosingSigned* operator ->() const { return &self; }
 };
-class Access {
+class UpdateAddHTLC {
 private:
-	LDKAccess self;
+	LDKUpdateAddHTLC self;
 public:
-	Access(const Access&) = delete;
-	Access(Access&& o) : self(o.self) { memset(&o, 0, sizeof(Access)); }
-	Access(LDKAccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccess)); }
-	operator LDKAccess() && { LDKAccess res = self; memset(&self, 0, sizeof(LDKAccess)); return res; }
-	~Access() { Access_free(self); }
-	Access& operator=(Access&& o) { Access_free(self); self = o.self; memset(&o, 0, sizeof(Access)); return *this; }
-	LDKAccess* operator &() { return &self; }
-	LDKAccess* operator ->() { return &self; }
-	const LDKAccess* operator &() const { return &self; }
-	const LDKAccess* operator ->() const { return &self; }
+	UpdateAddHTLC(const UpdateAddHTLC&) = delete;
+	UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
+	UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
+	operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
+	~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
+	UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
+	LDKUpdateAddHTLC* operator &() { return &self; }
+	LDKUpdateAddHTLC* operator ->() { return &self; }
+	const LDKUpdateAddHTLC* operator &() const { return &self; }
+	const LDKUpdateAddHTLC* operator ->() const { return &self; }
 };
-class Listen {
+class UpdateFulfillHTLC {
 private:
-	LDKListen self;
+	LDKUpdateFulfillHTLC self;
 public:
-	Listen(const Listen&) = delete;
-	Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
-	Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
-	operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
-	~Listen() { Listen_free(self); }
-	Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
-	LDKListen* operator &() { return &self; }
-	LDKListen* operator ->() { return &self; }
-	const LDKListen* operator &() const { return &self; }
-	const LDKListen* operator ->() const { return &self; }
+	UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
+	UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
+	UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
+	operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
+	~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
+	UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
+	LDKUpdateFulfillHTLC* operator &() { return &self; }
+	LDKUpdateFulfillHTLC* operator ->() { return &self; }
+	const LDKUpdateFulfillHTLC* operator &() const { return &self; }
+	const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
 };
-class Watch {
+class UpdateFailHTLC {
 private:
-	LDKWatch self;
+	LDKUpdateFailHTLC self;
 public:
-	Watch(const Watch&) = delete;
-	Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
-	Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
-	operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
-	~Watch() { Watch_free(self); }
-	Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
-	LDKWatch* operator &() { return &self; }
-	LDKWatch* operator ->() { return &self; }
-	const LDKWatch* operator &() const { return &self; }
-	const LDKWatch* operator ->() const { return &self; }
+	UpdateFailHTLC(const UpdateFailHTLC&) = delete;
+	UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
+	UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
+	operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
+	~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
+	UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
+	LDKUpdateFailHTLC* operator &() { return &self; }
+	LDKUpdateFailHTLC* operator ->() { return &self; }
+	const LDKUpdateFailHTLC* operator &() const { return &self; }
+	const LDKUpdateFailHTLC* operator ->() const { return &self; }
 };
-class Filter {
+class UpdateFailMalformedHTLC {
 private:
-	LDKFilter self;
+	LDKUpdateFailMalformedHTLC self;
 public:
-	Filter(const Filter&) = delete;
-	Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
-	Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
-	operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
-	~Filter() { Filter_free(self); }
-	Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
-	LDKFilter* operator &() { return &self; }
-	LDKFilter* operator ->() { return &self; }
-	const LDKFilter* operator &() const { return &self; }
-	const LDKFilter* operator ->() const { return &self; }
+	UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
+	UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
+	UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
+	operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
+	~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
+	UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
+	LDKUpdateFailMalformedHTLC* operator &() { return &self; }
+	LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
+	const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
+	const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
 };
-class WatchedOutput {
+class CommitmentSigned {
 private:
-	LDKWatchedOutput self;
+	LDKCommitmentSigned self;
 public:
-	WatchedOutput(const WatchedOutput&) = delete;
-	WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
-	WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
-	operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
-	~WatchedOutput() { WatchedOutput_free(self); }
-	WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
-	LDKWatchedOutput* operator &() { return &self; }
-	LDKWatchedOutput* operator ->() { return &self; }
-	const LDKWatchedOutput* operator &() const { return &self; }
-	const LDKWatchedOutput* operator ->() const { return &self; }
+	CommitmentSigned(const CommitmentSigned&) = delete;
+	CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
+	CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
+	operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
+	~CommitmentSigned() { CommitmentSigned_free(self); }
+	CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
+	LDKCommitmentSigned* operator &() { return &self; }
+	LDKCommitmentSigned* operator ->() { return &self; }
+	const LDKCommitmentSigned* operator &() const { return &self; }
+	const LDKCommitmentSigned* operator ->() const { return &self; }
 };
-class BroadcasterInterface {
+class RevokeAndACK {
 private:
-	LDKBroadcasterInterface self;
+	LDKRevokeAndACK self;
 public:
-	BroadcasterInterface(const BroadcasterInterface&) = delete;
-	BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
-	BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
-	operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
-	~BroadcasterInterface() { BroadcasterInterface_free(self); }
-	BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
-	LDKBroadcasterInterface* operator &() { return &self; }
-	LDKBroadcasterInterface* operator ->() { return &self; }
-	const LDKBroadcasterInterface* operator &() const { return &self; }
-	const LDKBroadcasterInterface* operator ->() const { return &self; }
+	RevokeAndACK(const RevokeAndACK&) = delete;
+	RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
+	RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
+	operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
+	~RevokeAndACK() { RevokeAndACK_free(self); }
+	RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
+	LDKRevokeAndACK* operator &() { return &self; }
+	LDKRevokeAndACK* operator ->() { return &self; }
+	const LDKRevokeAndACK* operator &() const { return &self; }
+	const LDKRevokeAndACK* operator ->() const { return &self; }
 };
-class ConfirmationTarget {
+class UpdateFee {
 private:
-	LDKConfirmationTarget self;
+	LDKUpdateFee self;
 public:
-	ConfirmationTarget(const ConfirmationTarget&) = delete;
-	ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
-	ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
-	operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
-	ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
-	LDKConfirmationTarget* operator &() { return &self; }
-	LDKConfirmationTarget* operator ->() { return &self; }
-	const LDKConfirmationTarget* operator &() const { return &self; }
-	const LDKConfirmationTarget* operator ->() const { return &self; }
+	UpdateFee(const UpdateFee&) = delete;
+	UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
+	UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
+	operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
+	~UpdateFee() { UpdateFee_free(self); }
+	UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
+	LDKUpdateFee* operator &() { return &self; }
+	LDKUpdateFee* operator ->() { return &self; }
+	const LDKUpdateFee* operator &() const { return &self; }
+	const LDKUpdateFee* operator ->() const { return &self; }
 };
-class FeeEstimator {
+class DataLossProtect {
 private:
-	LDKFeeEstimator self;
+	LDKDataLossProtect self;
 public:
-	FeeEstimator(const FeeEstimator&) = delete;
-	FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
-	FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
-	operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
-	~FeeEstimator() { FeeEstimator_free(self); }
-	FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
-	LDKFeeEstimator* operator &() { return &self; }
-	LDKFeeEstimator* operator ->() { return &self; }
-	const LDKFeeEstimator* operator &() const { return &self; }
-	const LDKFeeEstimator* operator ->() const { return &self; }
+	DataLossProtect(const DataLossProtect&) = delete;
+	DataLossProtect(DataLossProtect&& o) : self(o.self) { memset(&o, 0, sizeof(DataLossProtect)); }
+	DataLossProtect(LDKDataLossProtect&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDataLossProtect)); }
+	operator LDKDataLossProtect() && { LDKDataLossProtect res = self; memset(&self, 0, sizeof(LDKDataLossProtect)); return res; }
+	~DataLossProtect() { DataLossProtect_free(self); }
+	DataLossProtect& operator=(DataLossProtect&& o) { DataLossProtect_free(self); self = o.self; memset(&o, 0, sizeof(DataLossProtect)); return *this; }
+	LDKDataLossProtect* operator &() { return &self; }
+	LDKDataLossProtect* operator ->() { return &self; }
+	const LDKDataLossProtect* operator &() const { return &self; }
+	const LDKDataLossProtect* operator ->() const { return &self; }
 };
-class ChannelManager {
+class ChannelReestablish {
 private:
-	LDKChannelManager self;
+	LDKChannelReestablish self;
 public:
-	ChannelManager(const ChannelManager&) = delete;
-	ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
-	ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
-	operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
-	~ChannelManager() { ChannelManager_free(self); }
-	ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
-	LDKChannelManager* operator &() { return &self; }
-	LDKChannelManager* operator ->() { return &self; }
-	const LDKChannelManager* operator &() const { return &self; }
-	const LDKChannelManager* operator ->() const { return &self; }
+	ChannelReestablish(const ChannelReestablish&) = delete;
+	ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
+	ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
+	operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
+	~ChannelReestablish() { ChannelReestablish_free(self); }
+	ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
+	LDKChannelReestablish* operator &() { return &self; }
+	LDKChannelReestablish* operator ->() { return &self; }
+	const LDKChannelReestablish* operator &() const { return &self; }
+	const LDKChannelReestablish* operator ->() const { return &self; }
 };
-class ChainParameters {
+class AnnouncementSignatures {
 private:
-	LDKChainParameters self;
+	LDKAnnouncementSignatures self;
 public:
-	ChainParameters(const ChainParameters&) = delete;
-	ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
-	ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
-	operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
-	~ChainParameters() { ChainParameters_free(self); }
-	ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
-	LDKChainParameters* operator &() { return &self; }
-	LDKChainParameters* operator ->() { return &self; }
-	const LDKChainParameters* operator &() const { return &self; }
-	const LDKChainParameters* operator ->() const { return &self; }
+	AnnouncementSignatures(const AnnouncementSignatures&) = delete;
+	AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
+	AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
+	operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
+	~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
+	AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
+	LDKAnnouncementSignatures* operator &() { return &self; }
+	LDKAnnouncementSignatures* operator ->() { return &self; }
+	const LDKAnnouncementSignatures* operator &() const { return &self; }
+	const LDKAnnouncementSignatures* operator ->() const { return &self; }
 };
-class BestBlock {
+class NetAddress {
 private:
-	LDKBestBlock self;
+	LDKNetAddress self;
 public:
-	BestBlock(const BestBlock&) = delete;
-	BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
-	BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
-	operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
-	~BestBlock() { BestBlock_free(self); }
-	BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
-	LDKBestBlock* operator &() { return &self; }
-	LDKBestBlock* operator ->() { return &self; }
-	const LDKBestBlock* operator &() const { return &self; }
-	const LDKBestBlock* operator ->() const { return &self; }
+	NetAddress(const NetAddress&) = delete;
+	NetAddress(NetAddress&& o) : self(o.self) { memset(&o, 0, sizeof(NetAddress)); }
+	NetAddress(LDKNetAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetAddress)); }
+	operator LDKNetAddress() && { LDKNetAddress res = self; memset(&self, 0, sizeof(LDKNetAddress)); return res; }
+	~NetAddress() { NetAddress_free(self); }
+	NetAddress& operator=(NetAddress&& o) { NetAddress_free(self); self = o.self; memset(&o, 0, sizeof(NetAddress)); return *this; }
+	LDKNetAddress* operator &() { return &self; }
+	LDKNetAddress* operator ->() { return &self; }
+	const LDKNetAddress* operator &() const { return &self; }
+	const LDKNetAddress* operator ->() const { return &self; }
 };
-class ChannelDetails {
+class UnsignedNodeAnnouncement {
 private:
-	LDKChannelDetails self;
+	LDKUnsignedNodeAnnouncement self;
 public:
-	ChannelDetails(const ChannelDetails&) = delete;
-	ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
-	ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
-	operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
-	~ChannelDetails() { ChannelDetails_free(self); }
-	ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
-	LDKChannelDetails* operator &() { return &self; }
-	LDKChannelDetails* operator ->() { return &self; }
-	const LDKChannelDetails* operator &() const { return &self; }
-	const LDKChannelDetails* operator ->() const { return &self; }
+	UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
+	UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
+	UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
+	operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
+	~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
+	UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
+	LDKUnsignedNodeAnnouncement* operator &() { return &self; }
+	LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
+	const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
+	const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
 };
-class PaymentSendFailure {
+class NodeAnnouncement {
 private:
-	LDKPaymentSendFailure self;
+	LDKNodeAnnouncement self;
 public:
-	PaymentSendFailure(const PaymentSendFailure&) = delete;
-	PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
-	PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
-	operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
-	~PaymentSendFailure() { PaymentSendFailure_free(self); }
-	PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
-	LDKPaymentSendFailure* operator &() { return &self; }
-	LDKPaymentSendFailure* operator ->() { return &self; }
-	const LDKPaymentSendFailure* operator &() const { return &self; }
-	const LDKPaymentSendFailure* operator ->() const { return &self; }
+	NodeAnnouncement(const NodeAnnouncement&) = delete;
+	NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
+	NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
+	operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
+	~NodeAnnouncement() { NodeAnnouncement_free(self); }
+	NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
+	LDKNodeAnnouncement* operator &() { return &self; }
+	LDKNodeAnnouncement* operator ->() { return &self; }
+	const LDKNodeAnnouncement* operator &() const { return &self; }
+	const LDKNodeAnnouncement* operator ->() const { return &self; }
 };
-class ChannelManagerReadArgs {
+class UnsignedChannelAnnouncement {
 private:
-	LDKChannelManagerReadArgs self;
+	LDKUnsignedChannelAnnouncement self;
 public:
-	ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
-	ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
-	ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
-	operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
-	~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
-	ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
-	LDKChannelManagerReadArgs* operator &() { return &self; }
-	LDKChannelManagerReadArgs* operator ->() { return &self; }
-	const LDKChannelManagerReadArgs* operator &() const { return &self; }
-	const LDKChannelManagerReadArgs* operator ->() const { return &self; }
+	UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
+	UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
+	UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
+	operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
+	~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
+	UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
+	LDKUnsignedChannelAnnouncement* operator &() { return &self; }
+	LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
+	const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
+	const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
 };
-class DelayedPaymentOutputDescriptor {
+class ChannelAnnouncement {
 private:
-	LDKDelayedPaymentOutputDescriptor self;
+	LDKChannelAnnouncement self;
 public:
-	DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
-	DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
-	DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
-	operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
-	~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
-	DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
-	LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
-	LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
-	const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
-	const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
+	ChannelAnnouncement(const ChannelAnnouncement&) = delete;
+	ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
+	ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
+	operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
+	~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
+	ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
+	LDKChannelAnnouncement* operator &() { return &self; }
+	LDKChannelAnnouncement* operator ->() { return &self; }
+	const LDKChannelAnnouncement* operator &() const { return &self; }
+	const LDKChannelAnnouncement* operator ->() const { return &self; }
 };
-class StaticPaymentOutputDescriptor {
+class UnsignedChannelUpdate {
 private:
-	LDKStaticPaymentOutputDescriptor self;
+	LDKUnsignedChannelUpdate self;
 public:
-	StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
-	StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
-	StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
-	operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
-	~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
-	StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
-	LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
-	LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
-	const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
-	const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
+	UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
+	UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
+	UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
+	operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
+	~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
+	UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
+	LDKUnsignedChannelUpdate* operator &() { return &self; }
+	LDKUnsignedChannelUpdate* operator ->() { return &self; }
+	const LDKUnsignedChannelUpdate* operator &() const { return &self; }
+	const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
 };
-class SpendableOutputDescriptor {
+class ChannelUpdate {
 private:
-	LDKSpendableOutputDescriptor self;
+	LDKChannelUpdate self;
 public:
-	SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
-	SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
-	SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
-	operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
-	~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
-	SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
-	LDKSpendableOutputDescriptor* operator &() { return &self; }
-	LDKSpendableOutputDescriptor* operator ->() { return &self; }
-	const LDKSpendableOutputDescriptor* operator &() const { return &self; }
-	const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
-};
-class BaseSign {
-private:
+	ChannelUpdate(const ChannelUpdate&) = delete;
+	ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
+	ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
+	operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
+	~ChannelUpdate() { ChannelUpdate_free(self); }
+	ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
+	LDKChannelUpdate* operator &() { return &self; }
+	LDKChannelUpdate* operator ->() { return &self; }
+	const LDKChannelUpdate* operator &() const { return &self; }
+	const LDKChannelUpdate* operator ->() const { return &self; }
+};
+class QueryChannelRange {
+private:
+	LDKQueryChannelRange self;
+public:
+	QueryChannelRange(const QueryChannelRange&) = delete;
+	QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
+	QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
+	operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
+	~QueryChannelRange() { QueryChannelRange_free(self); }
+	QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
+	LDKQueryChannelRange* operator &() { return &self; }
+	LDKQueryChannelRange* operator ->() { return &self; }
+	const LDKQueryChannelRange* operator &() const { return &self; }
+	const LDKQueryChannelRange* operator ->() const { return &self; }
+};
+class ReplyChannelRange {
+private:
+	LDKReplyChannelRange self;
+public:
+	ReplyChannelRange(const ReplyChannelRange&) = delete;
+	ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
+	ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
+	operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
+	~ReplyChannelRange() { ReplyChannelRange_free(self); }
+	ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
+	LDKReplyChannelRange* operator &() { return &self; }
+	LDKReplyChannelRange* operator ->() { return &self; }
+	const LDKReplyChannelRange* operator &() const { return &self; }
+	const LDKReplyChannelRange* operator ->() const { return &self; }
+};
+class QueryShortChannelIds {
+private:
+	LDKQueryShortChannelIds self;
+public:
+	QueryShortChannelIds(const QueryShortChannelIds&) = delete;
+	QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
+	QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
+	operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
+	~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
+	QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
+	LDKQueryShortChannelIds* operator &() { return &self; }
+	LDKQueryShortChannelIds* operator ->() { return &self; }
+	const LDKQueryShortChannelIds* operator &() const { return &self; }
+	const LDKQueryShortChannelIds* operator ->() const { return &self; }
+};
+class ReplyShortChannelIdsEnd {
+private:
+	LDKReplyShortChannelIdsEnd self;
+public:
+	ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
+	ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
+	ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
+	operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
+	~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
+	ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
+	LDKReplyShortChannelIdsEnd* operator &() { return &self; }
+	LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
+	const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
+	const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
+};
+class GossipTimestampFilter {
+private:
+	LDKGossipTimestampFilter self;
+public:
+	GossipTimestampFilter(const GossipTimestampFilter&) = delete;
+	GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
+	GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
+	operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
+	~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
+	GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
+	LDKGossipTimestampFilter* operator &() { return &self; }
+	LDKGossipTimestampFilter* operator ->() { return &self; }
+	const LDKGossipTimestampFilter* operator &() const { return &self; }
+	const LDKGossipTimestampFilter* operator ->() const { return &self; }
+};
+class ErrorAction {
+private:
+	LDKErrorAction self;
+public:
+	ErrorAction(const ErrorAction&) = delete;
+	ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
+	ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
+	operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
+	~ErrorAction() { ErrorAction_free(self); }
+	ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
+	LDKErrorAction* operator &() { return &self; }
+	LDKErrorAction* operator ->() { return &self; }
+	const LDKErrorAction* operator &() const { return &self; }
+	const LDKErrorAction* operator ->() const { return &self; }
+};
+class LightningError {
+private:
+	LDKLightningError self;
+public:
+	LightningError(const LightningError&) = delete;
+	LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
+	LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
+	operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
+	~LightningError() { LightningError_free(self); }
+	LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
+	LDKLightningError* operator &() { return &self; }
+	LDKLightningError* operator ->() { return &self; }
+	const LDKLightningError* operator &() const { return &self; }
+	const LDKLightningError* operator ->() const { return &self; }
+};
+class CommitmentUpdate {
+private:
+	LDKCommitmentUpdate self;
+public:
+	CommitmentUpdate(const CommitmentUpdate&) = delete;
+	CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
+	CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
+	operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
+	~CommitmentUpdate() { CommitmentUpdate_free(self); }
+	CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
+	LDKCommitmentUpdate* operator &() { return &self; }
+	LDKCommitmentUpdate* operator ->() { return &self; }
+	const LDKCommitmentUpdate* operator &() const { return &self; }
+	const LDKCommitmentUpdate* operator ->() const { return &self; }
+};
+class HTLCFailChannelUpdate {
+private:
+	LDKHTLCFailChannelUpdate self;
+public:
+	HTLCFailChannelUpdate(const HTLCFailChannelUpdate&) = delete;
+	HTLCFailChannelUpdate(HTLCFailChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCFailChannelUpdate)); }
+	HTLCFailChannelUpdate(LDKHTLCFailChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCFailChannelUpdate)); }
+	operator LDKHTLCFailChannelUpdate() && { LDKHTLCFailChannelUpdate res = self; memset(&self, 0, sizeof(LDKHTLCFailChannelUpdate)); return res; }
+	~HTLCFailChannelUpdate() { HTLCFailChannelUpdate_free(self); }
+	HTLCFailChannelUpdate& operator=(HTLCFailChannelUpdate&& o) { HTLCFailChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCFailChannelUpdate)); return *this; }
+	LDKHTLCFailChannelUpdate* operator &() { return &self; }
+	LDKHTLCFailChannelUpdate* operator ->() { return &self; }
+	const LDKHTLCFailChannelUpdate* operator &() const { return &self; }
+	const LDKHTLCFailChannelUpdate* operator ->() const { return &self; }
+};
+class ChannelMessageHandler {
+private:
+	LDKChannelMessageHandler self;
+public:
+	ChannelMessageHandler(const ChannelMessageHandler&) = delete;
+	ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
+	ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
+	operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
+	~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
+	ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
+	LDKChannelMessageHandler* operator &() { return &self; }
+	LDKChannelMessageHandler* operator ->() { return &self; }
+	const LDKChannelMessageHandler* operator &() const { return &self; }
+	const LDKChannelMessageHandler* operator ->() const { return &self; }
+};
+class RoutingMessageHandler {
+private:
+	LDKRoutingMessageHandler self;
+public:
+	RoutingMessageHandler(const RoutingMessageHandler&) = delete;
+	RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
+	RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
+	operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
+	~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
+	RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
+	LDKRoutingMessageHandler* operator &() { return &self; }
+	LDKRoutingMessageHandler* operator ->() { return &self; }
+	const LDKRoutingMessageHandler* operator &() const { return &self; }
+	const LDKRoutingMessageHandler* operator ->() const { return &self; }
+};
+class Level {
+private:
+	LDKLevel self;
+public:
+	Level(const Level&) = delete;
+	Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
+	Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
+	operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
+	Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
+	LDKLevel* operator &() { return &self; }
+	LDKLevel* operator ->() { return &self; }
+	const LDKLevel* operator &() const { return &self; }
+	const LDKLevel* operator ->() const { return &self; }
+};
+class Logger {
+private:
+	LDKLogger self;
+public:
+	Logger(const Logger&) = delete;
+	Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
+	Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
+	operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
+	~Logger() { Logger_free(self); }
+	Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
+	LDKLogger* operator &() { return &self; }
+	LDKLogger* operator ->() { return &self; }
+	const LDKLogger* operator &() const { return &self; }
+	const LDKLogger* operator ->() const { return &self; }
+};
+class DelayedPaymentOutputDescriptor {
+private:
+	LDKDelayedPaymentOutputDescriptor self;
+public:
+	DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
+	DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
+	DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
+	operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
+	~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
+	DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
+	LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
+	LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
+	const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
+	const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
+};
+class StaticPaymentOutputDescriptor {
+private:
+	LDKStaticPaymentOutputDescriptor self;
+public:
+	StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
+	StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
+	StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
+	operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
+	~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
+	StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
+	LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
+	LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
+	const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
+	const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
+};
+class SpendableOutputDescriptor {
+private:
+	LDKSpendableOutputDescriptor self;
+public:
+	SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
+	SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
+	SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
+	operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
+	~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
+	SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
+	LDKSpendableOutputDescriptor* operator &() { return &self; }
+	LDKSpendableOutputDescriptor* operator ->() { return &self; }
+	const LDKSpendableOutputDescriptor* operator &() const { return &self; }
+	const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
+};
+class BaseSign {
+private:
 	LDKBaseSign self;
 public:
 	BaseSign(const BaseSign&) = delete;
@@ -1031,680 +1852,155 @@ public:
 	const LDKKeysInterface* operator &() const { return &self; }
 	const LDKKeysInterface* operator ->() const { return &self; }
 };
-class InMemorySigner {
-private:
-	LDKInMemorySigner self;
-public:
-	InMemorySigner(const InMemorySigner&) = delete;
-	InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
-	InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
-	operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
-	~InMemorySigner() { InMemorySigner_free(self); }
-	InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
-	LDKInMemorySigner* operator &() { return &self; }
-	LDKInMemorySigner* operator ->() { return &self; }
-	const LDKInMemorySigner* operator &() const { return &self; }
-	const LDKInMemorySigner* operator ->() const { return &self; }
-};
-class KeysManager {
-private:
-	LDKKeysManager self;
-public:
-	KeysManager(const KeysManager&) = delete;
-	KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
-	KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
-	operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
-	~KeysManager() { KeysManager_free(self); }
-	KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
-	LDKKeysManager* operator &() { return &self; }
-	LDKKeysManager* operator ->() { return &self; }
-	const LDKKeysManager* operator &() const { return &self; }
-	const LDKKeysManager* operator ->() const { return &self; }
-};
-class RouteHop {
-private:
-	LDKRouteHop self;
-public:
-	RouteHop(const RouteHop&) = delete;
-	RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
-	RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
-	operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
-	~RouteHop() { RouteHop_free(self); }
-	RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
-	LDKRouteHop* operator &() { return &self; }
-	LDKRouteHop* operator ->() { return &self; }
-	const LDKRouteHop* operator &() const { return &self; }
-	const LDKRouteHop* operator ->() const { return &self; }
-};
-class Route {
-private:
-	LDKRoute self;
-public:
-	Route(const Route&) = delete;
-	Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
-	Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
-	operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
-	~Route() { Route_free(self); }
-	Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
-	LDKRoute* operator &() { return &self; }
-	LDKRoute* operator ->() { return &self; }
-	const LDKRoute* operator &() const { return &self; }
-	const LDKRoute* operator ->() const { return &self; }
-};
-class RouteHint {
-private:
-	LDKRouteHint self;
-public:
-	RouteHint(const RouteHint&) = delete;
-	RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
-	RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
-	operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
-	~RouteHint() { RouteHint_free(self); }
-	RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
-	LDKRouteHint* operator &() { return &self; }
-	LDKRouteHint* operator ->() { return &self; }
-	const LDKRouteHint* operator &() const { return &self; }
-	const LDKRouteHint* operator ->() const { return &self; }
-};
-class DecodeError {
-private:
-	LDKDecodeError self;
-public:
-	DecodeError(const DecodeError&) = delete;
-	DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
-	DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
-	operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
-	~DecodeError() { DecodeError_free(self); }
-	DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
-	LDKDecodeError* operator &() { return &self; }
-	LDKDecodeError* operator ->() { return &self; }
-	const LDKDecodeError* operator &() const { return &self; }
-	const LDKDecodeError* operator ->() const { return &self; }
-};
-class Init {
-private:
-	LDKInit self;
-public:
-	Init(const Init&) = delete;
-	Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
-	Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
-	operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
-	~Init() { Init_free(self); }
-	Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
-	LDKInit* operator &() { return &self; }
-	LDKInit* operator ->() { return &self; }
-	const LDKInit* operator &() const { return &self; }
-	const LDKInit* operator ->() const { return &self; }
-};
-class ErrorMessage {
-private:
-	LDKErrorMessage self;
-public:
-	ErrorMessage(const ErrorMessage&) = delete;
-	ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
-	ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
-	operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
-	~ErrorMessage() { ErrorMessage_free(self); }
-	ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
-	LDKErrorMessage* operator &() { return &self; }
-	LDKErrorMessage* operator ->() { return &self; }
-	const LDKErrorMessage* operator &() const { return &self; }
-	const LDKErrorMessage* operator ->() const { return &self; }
-};
-class Ping {
-private:
-	LDKPing self;
-public:
-	Ping(const Ping&) = delete;
-	Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
-	Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
-	operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
-	~Ping() { Ping_free(self); }
-	Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
-	LDKPing* operator &() { return &self; }
-	LDKPing* operator ->() { return &self; }
-	const LDKPing* operator &() const { return &self; }
-	const LDKPing* operator ->() const { return &self; }
-};
-class Pong {
-private:
-	LDKPong self;
-public:
-	Pong(const Pong&) = delete;
-	Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
-	Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
-	operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
-	~Pong() { Pong_free(self); }
-	Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
-	LDKPong* operator &() { return &self; }
-	LDKPong* operator ->() { return &self; }
-	const LDKPong* operator &() const { return &self; }
-	const LDKPong* operator ->() const { return &self; }
-};
-class OpenChannel {
-private:
-	LDKOpenChannel self;
-public:
-	OpenChannel(const OpenChannel&) = delete;
-	OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
-	OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
-	operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
-	~OpenChannel() { OpenChannel_free(self); }
-	OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
-	LDKOpenChannel* operator &() { return &self; }
-	LDKOpenChannel* operator ->() { return &self; }
-	const LDKOpenChannel* operator &() const { return &self; }
-	const LDKOpenChannel* operator ->() const { return &self; }
-};
-class AcceptChannel {
-private:
-	LDKAcceptChannel self;
-public:
-	AcceptChannel(const AcceptChannel&) = delete;
-	AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
-	AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
-	operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
-	~AcceptChannel() { AcceptChannel_free(self); }
-	AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
-	LDKAcceptChannel* operator &() { return &self; }
-	LDKAcceptChannel* operator ->() { return &self; }
-	const LDKAcceptChannel* operator &() const { return &self; }
-	const LDKAcceptChannel* operator ->() const { return &self; }
-};
-class FundingCreated {
-private:
-	LDKFundingCreated self;
-public:
-	FundingCreated(const FundingCreated&) = delete;
-	FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
-	FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
-	operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
-	~FundingCreated() { FundingCreated_free(self); }
-	FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
-	LDKFundingCreated* operator &() { return &self; }
-	LDKFundingCreated* operator ->() { return &self; }
-	const LDKFundingCreated* operator &() const { return &self; }
-	const LDKFundingCreated* operator ->() const { return &self; }
-};
-class FundingSigned {
-private:
-	LDKFundingSigned self;
-public:
-	FundingSigned(const FundingSigned&) = delete;
-	FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
-	FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
-	operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
-	~FundingSigned() { FundingSigned_free(self); }
-	FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
-	LDKFundingSigned* operator &() { return &self; }
-	LDKFundingSigned* operator ->() { return &self; }
-	const LDKFundingSigned* operator &() const { return &self; }
-	const LDKFundingSigned* operator ->() const { return &self; }
-};
-class FundingLocked {
-private:
-	LDKFundingLocked self;
-public:
-	FundingLocked(const FundingLocked&) = delete;
-	FundingLocked(FundingLocked&& o) : self(o.self) { memset(&o, 0, sizeof(FundingLocked)); }
-	FundingLocked(LDKFundingLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingLocked)); }
-	operator LDKFundingLocked() && { LDKFundingLocked res = self; memset(&self, 0, sizeof(LDKFundingLocked)); return res; }
-	~FundingLocked() { FundingLocked_free(self); }
-	FundingLocked& operator=(FundingLocked&& o) { FundingLocked_free(self); self = o.self; memset(&o, 0, sizeof(FundingLocked)); return *this; }
-	LDKFundingLocked* operator &() { return &self; }
-	LDKFundingLocked* operator ->() { return &self; }
-	const LDKFundingLocked* operator &() const { return &self; }
-	const LDKFundingLocked* operator ->() const { return &self; }
-};
-class Shutdown {
-private:
-	LDKShutdown self;
-public:
-	Shutdown(const Shutdown&) = delete;
-	Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
-	Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
-	operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
-	~Shutdown() { Shutdown_free(self); }
-	Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
-	LDKShutdown* operator &() { return &self; }
-	LDKShutdown* operator ->() { return &self; }
-	const LDKShutdown* operator &() const { return &self; }
-	const LDKShutdown* operator ->() const { return &self; }
-};
-class ClosingSigned {
-private:
-	LDKClosingSigned self;
-public:
-	ClosingSigned(const ClosingSigned&) = delete;
-	ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
-	ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
-	operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
-	~ClosingSigned() { ClosingSigned_free(self); }
-	ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
-	LDKClosingSigned* operator &() { return &self; }
-	LDKClosingSigned* operator ->() { return &self; }
-	const LDKClosingSigned* operator &() const { return &self; }
-	const LDKClosingSigned* operator ->() const { return &self; }
-};
-class UpdateAddHTLC {
-private:
-	LDKUpdateAddHTLC self;
-public:
-	UpdateAddHTLC(const UpdateAddHTLC&) = delete;
-	UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
-	UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
-	operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
-	~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
-	UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
-	LDKUpdateAddHTLC* operator &() { return &self; }
-	LDKUpdateAddHTLC* operator ->() { return &self; }
-	const LDKUpdateAddHTLC* operator &() const { return &self; }
-	const LDKUpdateAddHTLC* operator ->() const { return &self; }
-};
-class UpdateFulfillHTLC {
-private:
-	LDKUpdateFulfillHTLC self;
-public:
-	UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
-	UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
-	UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
-	operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
-	~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
-	UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
-	LDKUpdateFulfillHTLC* operator &() { return &self; }
-	LDKUpdateFulfillHTLC* operator ->() { return &self; }
-	const LDKUpdateFulfillHTLC* operator &() const { return &self; }
-	const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
-};
-class UpdateFailHTLC {
-private:
-	LDKUpdateFailHTLC self;
-public:
-	UpdateFailHTLC(const UpdateFailHTLC&) = delete;
-	UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
-	UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
-	operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
-	~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
-	UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
-	LDKUpdateFailHTLC* operator &() { return &self; }
-	LDKUpdateFailHTLC* operator ->() { return &self; }
-	const LDKUpdateFailHTLC* operator &() const { return &self; }
-	const LDKUpdateFailHTLC* operator ->() const { return &self; }
-};
-class UpdateFailMalformedHTLC {
-private:
-	LDKUpdateFailMalformedHTLC self;
-public:
-	UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
-	UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
-	UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
-	operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
-	~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
-	UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
-	LDKUpdateFailMalformedHTLC* operator &() { return &self; }
-	LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
-	const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
-	const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
-};
-class CommitmentSigned {
-private:
-	LDKCommitmentSigned self;
-public:
-	CommitmentSigned(const CommitmentSigned&) = delete;
-	CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
-	CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
-	operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
-	~CommitmentSigned() { CommitmentSigned_free(self); }
-	CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
-	LDKCommitmentSigned* operator &() { return &self; }
-	LDKCommitmentSigned* operator ->() { return &self; }
-	const LDKCommitmentSigned* operator &() const { return &self; }
-	const LDKCommitmentSigned* operator ->() const { return &self; }
-};
-class RevokeAndACK {
-private:
-	LDKRevokeAndACK self;
-public:
-	RevokeAndACK(const RevokeAndACK&) = delete;
-	RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
-	RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
-	operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
-	~RevokeAndACK() { RevokeAndACK_free(self); }
-	RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
-	LDKRevokeAndACK* operator &() { return &self; }
-	LDKRevokeAndACK* operator ->() { return &self; }
-	const LDKRevokeAndACK* operator &() const { return &self; }
-	const LDKRevokeAndACK* operator ->() const { return &self; }
-};
-class UpdateFee {
-private:
-	LDKUpdateFee self;
-public:
-	UpdateFee(const UpdateFee&) = delete;
-	UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
-	UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
-	operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
-	~UpdateFee() { UpdateFee_free(self); }
-	UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
-	LDKUpdateFee* operator &() { return &self; }
-	LDKUpdateFee* operator ->() { return &self; }
-	const LDKUpdateFee* operator &() const { return &self; }
-	const LDKUpdateFee* operator ->() const { return &self; }
-};
-class DataLossProtect {
-private:
-	LDKDataLossProtect self;
-public:
-	DataLossProtect(const DataLossProtect&) = delete;
-	DataLossProtect(DataLossProtect&& o) : self(o.self) { memset(&o, 0, sizeof(DataLossProtect)); }
-	DataLossProtect(LDKDataLossProtect&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDataLossProtect)); }
-	operator LDKDataLossProtect() && { LDKDataLossProtect res = self; memset(&self, 0, sizeof(LDKDataLossProtect)); return res; }
-	~DataLossProtect() { DataLossProtect_free(self); }
-	DataLossProtect& operator=(DataLossProtect&& o) { DataLossProtect_free(self); self = o.self; memset(&o, 0, sizeof(DataLossProtect)); return *this; }
-	LDKDataLossProtect* operator &() { return &self; }
-	LDKDataLossProtect* operator ->() { return &self; }
-	const LDKDataLossProtect* operator &() const { return &self; }
-	const LDKDataLossProtect* operator ->() const { return &self; }
-};
-class ChannelReestablish {
-private:
-	LDKChannelReestablish self;
-public:
-	ChannelReestablish(const ChannelReestablish&) = delete;
-	ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
-	ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
-	operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
-	~ChannelReestablish() { ChannelReestablish_free(self); }
-	ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
-	LDKChannelReestablish* operator &() { return &self; }
-	LDKChannelReestablish* operator ->() { return &self; }
-	const LDKChannelReestablish* operator &() const { return &self; }
-	const LDKChannelReestablish* operator ->() const { return &self; }
-};
-class AnnouncementSignatures {
-private:
-	LDKAnnouncementSignatures self;
-public:
-	AnnouncementSignatures(const AnnouncementSignatures&) = delete;
-	AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
-	AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
-	operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
-	~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
-	AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
-	LDKAnnouncementSignatures* operator &() { return &self; }
-	LDKAnnouncementSignatures* operator ->() { return &self; }
-	const LDKAnnouncementSignatures* operator &() const { return &self; }
-	const LDKAnnouncementSignatures* operator ->() const { return &self; }
-};
-class NetAddress {
-private:
-	LDKNetAddress self;
-public:
-	NetAddress(const NetAddress&) = delete;
-	NetAddress(NetAddress&& o) : self(o.self) { memset(&o, 0, sizeof(NetAddress)); }
-	NetAddress(LDKNetAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetAddress)); }
-	operator LDKNetAddress() && { LDKNetAddress res = self; memset(&self, 0, sizeof(LDKNetAddress)); return res; }
-	~NetAddress() { NetAddress_free(self); }
-	NetAddress& operator=(NetAddress&& o) { NetAddress_free(self); self = o.self; memset(&o, 0, sizeof(NetAddress)); return *this; }
-	LDKNetAddress* operator &() { return &self; }
-	LDKNetAddress* operator ->() { return &self; }
-	const LDKNetAddress* operator &() const { return &self; }
-	const LDKNetAddress* operator ->() const { return &self; }
-};
-class UnsignedNodeAnnouncement {
-private:
-	LDKUnsignedNodeAnnouncement self;
-public:
-	UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
-	UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
-	UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
-	operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
-	~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
-	UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
-	LDKUnsignedNodeAnnouncement* operator &() { return &self; }
-	LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
-	const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
-	const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
-};
-class NodeAnnouncement {
-private:
-	LDKNodeAnnouncement self;
-public:
-	NodeAnnouncement(const NodeAnnouncement&) = delete;
-	NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
-	NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
-	operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
-	~NodeAnnouncement() { NodeAnnouncement_free(self); }
-	NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
-	LDKNodeAnnouncement* operator &() { return &self; }
-	LDKNodeAnnouncement* operator ->() { return &self; }
-	const LDKNodeAnnouncement* operator &() const { return &self; }
-	const LDKNodeAnnouncement* operator ->() const { return &self; }
-};
-class UnsignedChannelAnnouncement {
-private:
-	LDKUnsignedChannelAnnouncement self;
-public:
-	UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
-	UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
-	UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
-	operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
-	~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
-	UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
-	LDKUnsignedChannelAnnouncement* operator &() { return &self; }
-	LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
-	const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
-	const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
-};
-class ChannelAnnouncement {
-private:
-	LDKChannelAnnouncement self;
-public:
-	ChannelAnnouncement(const ChannelAnnouncement&) = delete;
-	ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
-	ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
-	operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
-	~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
-	ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
-	LDKChannelAnnouncement* operator &() { return &self; }
-	LDKChannelAnnouncement* operator ->() { return &self; }
-	const LDKChannelAnnouncement* operator &() const { return &self; }
-	const LDKChannelAnnouncement* operator ->() const { return &self; }
-};
-class UnsignedChannelUpdate {
-private:
-	LDKUnsignedChannelUpdate self;
-public:
-	UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
-	UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
-	UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
-	operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
-	~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
-	UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
-	LDKUnsignedChannelUpdate* operator &() { return &self; }
-	LDKUnsignedChannelUpdate* operator ->() { return &self; }
-	const LDKUnsignedChannelUpdate* operator &() const { return &self; }
-	const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
-};
-class ChannelUpdate {
-private:
-	LDKChannelUpdate self;
-public:
-	ChannelUpdate(const ChannelUpdate&) = delete;
-	ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
-	ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
-	operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
-	~ChannelUpdate() { ChannelUpdate_free(self); }
-	ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
-	LDKChannelUpdate* operator &() { return &self; }
-	LDKChannelUpdate* operator ->() { return &self; }
-	const LDKChannelUpdate* operator &() const { return &self; }
-	const LDKChannelUpdate* operator ->() const { return &self; }
-};
-class QueryChannelRange {
-private:
-	LDKQueryChannelRange self;
-public:
-	QueryChannelRange(const QueryChannelRange&) = delete;
-	QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
-	QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
-	operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
-	~QueryChannelRange() { QueryChannelRange_free(self); }
-	QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
-	LDKQueryChannelRange* operator &() { return &self; }
-	LDKQueryChannelRange* operator ->() { return &self; }
-	const LDKQueryChannelRange* operator &() const { return &self; }
-	const LDKQueryChannelRange* operator ->() const { return &self; }
-};
-class ReplyChannelRange {
+class InMemorySigner {
 private:
-	LDKReplyChannelRange self;
+	LDKInMemorySigner self;
 public:
-	ReplyChannelRange(const ReplyChannelRange&) = delete;
-	ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
-	ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
-	operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
-	~ReplyChannelRange() { ReplyChannelRange_free(self); }
-	ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
-	LDKReplyChannelRange* operator &() { return &self; }
-	LDKReplyChannelRange* operator ->() { return &self; }
-	const LDKReplyChannelRange* operator &() const { return &self; }
-	const LDKReplyChannelRange* operator ->() const { return &self; }
+	InMemorySigner(const InMemorySigner&) = delete;
+	InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
+	InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
+	operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
+	~InMemorySigner() { InMemorySigner_free(self); }
+	InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
+	LDKInMemorySigner* operator &() { return &self; }
+	LDKInMemorySigner* operator ->() { return &self; }
+	const LDKInMemorySigner* operator &() const { return &self; }
+	const LDKInMemorySigner* operator ->() const { return &self; }
 };
-class QueryShortChannelIds {
+class KeysManager {
 private:
-	LDKQueryShortChannelIds self;
+	LDKKeysManager self;
 public:
-	QueryShortChannelIds(const QueryShortChannelIds&) = delete;
-	QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
-	QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
-	operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
-	~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
-	QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
-	LDKQueryShortChannelIds* operator &() { return &self; }
-	LDKQueryShortChannelIds* operator ->() { return &self; }
-	const LDKQueryShortChannelIds* operator &() const { return &self; }
-	const LDKQueryShortChannelIds* operator ->() const { return &self; }
+	KeysManager(const KeysManager&) = delete;
+	KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
+	KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
+	operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
+	~KeysManager() { KeysManager_free(self); }
+	KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
+	LDKKeysManager* operator &() { return &self; }
+	LDKKeysManager* operator ->() { return &self; }
+	const LDKKeysManager* operator &() const { return &self; }
+	const LDKKeysManager* operator ->() const { return &self; }
 };
-class ReplyShortChannelIdsEnd {
+class ChainMonitor {
 private:
-	LDKReplyShortChannelIdsEnd self;
+	LDKChainMonitor self;
 public:
-	ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
-	ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
-	ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
-	operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
-	~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
-	ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
-	LDKReplyShortChannelIdsEnd* operator &() { return &self; }
-	LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
-	const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
-	const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
+	ChainMonitor(const ChainMonitor&) = delete;
+	ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
+	ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
+	operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
+	~ChainMonitor() { ChainMonitor_free(self); }
+	ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
+	LDKChainMonitor* operator &() { return &self; }
+	LDKChainMonitor* operator ->() { return &self; }
+	const LDKChainMonitor* operator &() const { return &self; }
+	const LDKChainMonitor* operator ->() const { return &self; }
 };
-class GossipTimestampFilter {
+class FilesystemPersister {
 private:
-	LDKGossipTimestampFilter self;
+	LDKFilesystemPersister self;
 public:
-	GossipTimestampFilter(const GossipTimestampFilter&) = delete;
-	GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
-	GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
-	operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
-	~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
-	GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
-	LDKGossipTimestampFilter* operator &() { return &self; }
-	LDKGossipTimestampFilter* operator ->() { return &self; }
-	const LDKGossipTimestampFilter* operator &() const { return &self; }
-	const LDKGossipTimestampFilter* operator ->() const { return &self; }
+	FilesystemPersister(const FilesystemPersister&) = delete;
+	FilesystemPersister(FilesystemPersister&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemPersister)); }
+	FilesystemPersister(LDKFilesystemPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemPersister)); }
+	operator LDKFilesystemPersister() && { LDKFilesystemPersister res = self; memset(&self, 0, sizeof(LDKFilesystemPersister)); return res; }
+	~FilesystemPersister() { FilesystemPersister_free(self); }
+	FilesystemPersister& operator=(FilesystemPersister&& o) { FilesystemPersister_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemPersister)); return *this; }
+	LDKFilesystemPersister* operator &() { return &self; }
+	LDKFilesystemPersister* operator ->() { return &self; }
+	const LDKFilesystemPersister* operator &() const { return &self; }
+	const LDKFilesystemPersister* operator ->() const { return &self; }
 };
-class ErrorAction {
+class ChannelManager {
 private:
-	LDKErrorAction self;
+	LDKChannelManager self;
 public:
-	ErrorAction(const ErrorAction&) = delete;
-	ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
-	ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
-	operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
-	~ErrorAction() { ErrorAction_free(self); }
-	ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
-	LDKErrorAction* operator &() { return &self; }
-	LDKErrorAction* operator ->() { return &self; }
-	const LDKErrorAction* operator &() const { return &self; }
-	const LDKErrorAction* operator ->() const { return &self; }
+	ChannelManager(const ChannelManager&) = delete;
+	ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
+	ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
+	operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
+	~ChannelManager() { ChannelManager_free(self); }
+	ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
+	LDKChannelManager* operator &() { return &self; }
+	LDKChannelManager* operator ->() { return &self; }
+	const LDKChannelManager* operator &() const { return &self; }
+	const LDKChannelManager* operator ->() const { return &self; }
 };
-class LightningError {
+class ChainParameters {
 private:
-	LDKLightningError self;
+	LDKChainParameters self;
 public:
-	LightningError(const LightningError&) = delete;
-	LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
-	LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
-	operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
-	~LightningError() { LightningError_free(self); }
-	LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
-	LDKLightningError* operator &() { return &self; }
-	LDKLightningError* operator ->() { return &self; }
-	const LDKLightningError* operator &() const { return &self; }
-	const LDKLightningError* operator ->() const { return &self; }
+	ChainParameters(const ChainParameters&) = delete;
+	ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
+	ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
+	operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
+	~ChainParameters() { ChainParameters_free(self); }
+	ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
+	LDKChainParameters* operator &() { return &self; }
+	LDKChainParameters* operator ->() { return &self; }
+	const LDKChainParameters* operator &() const { return &self; }
+	const LDKChainParameters* operator ->() const { return &self; }
 };
-class CommitmentUpdate {
+class BestBlock {
 private:
-	LDKCommitmentUpdate self;
+	LDKBestBlock self;
 public:
-	CommitmentUpdate(const CommitmentUpdate&) = delete;
-	CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
-	CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
-	operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
-	~CommitmentUpdate() { CommitmentUpdate_free(self); }
-	CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
-	LDKCommitmentUpdate* operator &() { return &self; }
-	LDKCommitmentUpdate* operator ->() { return &self; }
-	const LDKCommitmentUpdate* operator &() const { return &self; }
-	const LDKCommitmentUpdate* operator ->() const { return &self; }
+	BestBlock(const BestBlock&) = delete;
+	BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
+	BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
+	operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
+	~BestBlock() { BestBlock_free(self); }
+	BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
+	LDKBestBlock* operator &() { return &self; }
+	LDKBestBlock* operator ->() { return &self; }
+	const LDKBestBlock* operator &() const { return &self; }
+	const LDKBestBlock* operator ->() const { return &self; }
 };
-class HTLCFailChannelUpdate {
+class ChannelDetails {
 private:
-	LDKHTLCFailChannelUpdate self;
+	LDKChannelDetails self;
 public:
-	HTLCFailChannelUpdate(const HTLCFailChannelUpdate&) = delete;
-	HTLCFailChannelUpdate(HTLCFailChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCFailChannelUpdate)); }
-	HTLCFailChannelUpdate(LDKHTLCFailChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCFailChannelUpdate)); }
-	operator LDKHTLCFailChannelUpdate() && { LDKHTLCFailChannelUpdate res = self; memset(&self, 0, sizeof(LDKHTLCFailChannelUpdate)); return res; }
-	~HTLCFailChannelUpdate() { HTLCFailChannelUpdate_free(self); }
-	HTLCFailChannelUpdate& operator=(HTLCFailChannelUpdate&& o) { HTLCFailChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCFailChannelUpdate)); return *this; }
-	LDKHTLCFailChannelUpdate* operator &() { return &self; }
-	LDKHTLCFailChannelUpdate* operator ->() { return &self; }
-	const LDKHTLCFailChannelUpdate* operator &() const { return &self; }
-	const LDKHTLCFailChannelUpdate* operator ->() const { return &self; }
+	ChannelDetails(const ChannelDetails&) = delete;
+	ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
+	ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
+	operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
+	~ChannelDetails() { ChannelDetails_free(self); }
+	ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
+	LDKChannelDetails* operator &() { return &self; }
+	LDKChannelDetails* operator ->() { return &self; }
+	const LDKChannelDetails* operator &() const { return &self; }
+	const LDKChannelDetails* operator ->() const { return &self; }
 };
-class ChannelMessageHandler {
+class PaymentSendFailure {
 private:
-	LDKChannelMessageHandler self;
+	LDKPaymentSendFailure self;
 public:
-	ChannelMessageHandler(const ChannelMessageHandler&) = delete;
-	ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
-	ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
-	operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
-	~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
-	ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
-	LDKChannelMessageHandler* operator &() { return &self; }
-	LDKChannelMessageHandler* operator ->() { return &self; }
-	const LDKChannelMessageHandler* operator &() const { return &self; }
-	const LDKChannelMessageHandler* operator ->() const { return &self; }
+	PaymentSendFailure(const PaymentSendFailure&) = delete;
+	PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
+	PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
+	operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
+	~PaymentSendFailure() { PaymentSendFailure_free(self); }
+	PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
+	LDKPaymentSendFailure* operator &() { return &self; }
+	LDKPaymentSendFailure* operator ->() { return &self; }
+	const LDKPaymentSendFailure* operator &() const { return &self; }
+	const LDKPaymentSendFailure* operator ->() const { return &self; }
 };
-class RoutingMessageHandler {
+class ChannelManagerReadArgs {
 private:
-	LDKRoutingMessageHandler self;
+	LDKChannelManagerReadArgs self;
 public:
-	RoutingMessageHandler(const RoutingMessageHandler&) = delete;
-	RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
-	RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
-	operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
-	~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
-	RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
-	LDKRoutingMessageHandler* operator &() { return &self; }
-	LDKRoutingMessageHandler* operator ->() { return &self; }
-	const LDKRoutingMessageHandler* operator &() const { return &self; }
-	const LDKRoutingMessageHandler* operator ->() const { return &self; }
+	ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
+	ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
+	ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
+	operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
+	~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
+	ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
+	LDKChannelManagerReadArgs* operator &() { return &self; }
+	LDKChannelManagerReadArgs* operator ->() { return &self; }
+	const LDKChannelManagerReadArgs* operator &() const { return &self; }
+	const LDKChannelManagerReadArgs* operator ->() const { return &self; }
 };
 class CVec_SpendableOutputDescriptorZ {
 private:
@@ -1766,20 +2062,50 @@ public:
 	const LDKCResult_HTLCUpdateDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_u32TxOutZZ {
+class CVec_C2Tuple_u32TxOutZZ {
+private:
+	LDKCVec_C2Tuple_u32TxOutZZ self;
+public:
+	CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
+	CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
+	CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
+	operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
+	~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
+	CVec_C2Tuple_u32TxOutZZ& operator=(CVec_C2Tuple_u32TxOutZZ&& o) { CVec_C2Tuple_u32TxOutZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); return *this; }
+	LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
+};
+class CResult_ChannelAnnouncementDecodeErrorZ {
+private:
+	LDKCResult_ChannelAnnouncementDecodeErrorZ self;
+public:
+	CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
+	CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
+	CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
+	operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
+	~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
+	CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ChannelInfoDecodeErrorZ {
 private:
-	LDKCVec_C2Tuple_u32TxOutZZ self;
+	LDKCResult_ChannelInfoDecodeErrorZ self;
 public:
-	CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
-	CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
-	CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
-	operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
-	~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
-	CVec_C2Tuple_u32TxOutZZ& operator=(CVec_C2Tuple_u32TxOutZZ&& o) { CVec_C2Tuple_u32TxOutZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); return *this; }
-	LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
+	CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
+	CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
+	CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
+	operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
+	~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
+	CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
 };
 class C2Tuple_SignatureCVec_SignatureZZ {
 private:
@@ -1796,35 +2122,35 @@ public:
 	const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; }
 	const LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() const { return &self; }
 };
-class CResult_ChannelInfoDecodeErrorZ {
+class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
 private:
-	LDKCResult_ChannelInfoDecodeErrorZ self;
+	LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
 public:
-	CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
-	CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
-	CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
-	operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
-	~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
-	CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
-	LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
+	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(const CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&) = delete;
+	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
+	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
+	operator LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() && { LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return res; }
+	~CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); }
+	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ& operator=(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return *this; }
+	LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() { return &self; }
+	LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() { return &self; }
+	const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() const { return &self; }
+	const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() const { return &self; }
 };
-class CResult_ChannelAnnouncementDecodeErrorZ {
+class CResult_PositiveTimestampCreationErrorZ {
 private:
-	LDKCResult_ChannelAnnouncementDecodeErrorZ self;
+	LDKCResult_PositiveTimestampCreationErrorZ self;
 public:
-	CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
-	CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
-	CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
-	operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
-	~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
-	CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
-	LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
+	CResult_PositiveTimestampCreationErrorZ(const CResult_PositiveTimestampCreationErrorZ&) = delete;
+	CResult_PositiveTimestampCreationErrorZ(CResult_PositiveTimestampCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); }
+	CResult_PositiveTimestampCreationErrorZ(LDKCResult_PositiveTimestampCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); }
+	operator LDKCResult_PositiveTimestampCreationErrorZ() && { LDKCResult_PositiveTimestampCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); return res; }
+	~CResult_PositiveTimestampCreationErrorZ() { CResult_PositiveTimestampCreationErrorZ_free(self); }
+	CResult_PositiveTimestampCreationErrorZ& operator=(CResult_PositiveTimestampCreationErrorZ&& o) { CResult_PositiveTimestampCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); return *this; }
+	LDKCResult_PositiveTimestampCreationErrorZ* operator &() { return &self; }
+	LDKCResult_PositiveTimestampCreationErrorZ* operator ->() { return &self; }
+	const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
+	const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
 };
 class CResult_CVec_u8ZPeerHandleErrorZ {
 private:
@@ -1841,21 +2167,6 @@ public:
 	const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
 	const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
 };
-class CResult_InvoiceFeaturesDecodeErrorZ {
-private:
-	LDKCResult_InvoiceFeaturesDecodeErrorZ self;
-public:
-	CResult_InvoiceFeaturesDecodeErrorZ(const CResult_InvoiceFeaturesDecodeErrorZ&) = delete;
-	CResult_InvoiceFeaturesDecodeErrorZ(CResult_InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); }
-	CResult_InvoiceFeaturesDecodeErrorZ(LDKCResult_InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); }
-	operator LDKCResult_InvoiceFeaturesDecodeErrorZ() && { LDKCResult_InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); return res; }
-	~CResult_InvoiceFeaturesDecodeErrorZ() { CResult_InvoiceFeaturesDecodeErrorZ_free(self); }
-	CResult_InvoiceFeaturesDecodeErrorZ& operator=(CResult_InvoiceFeaturesDecodeErrorZ&& o) { CResult_InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); return *this; }
-	LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_ChannelMonitorUpdateDecodeErrorZ {
 private:
 	LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
@@ -1871,6 +2182,21 @@ public:
 	const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_InvoiceFeaturesDecodeErrorZ {
+private:
+	LDKCResult_InvoiceFeaturesDecodeErrorZ self;
+public:
+	CResult_InvoiceFeaturesDecodeErrorZ(const CResult_InvoiceFeaturesDecodeErrorZ&) = delete;
+	CResult_InvoiceFeaturesDecodeErrorZ(CResult_InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); }
+	CResult_InvoiceFeaturesDecodeErrorZ(LDKCResult_InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); }
+	operator LDKCResult_InvoiceFeaturesDecodeErrorZ() && { LDKCResult_InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); return res; }
+	~CResult_InvoiceFeaturesDecodeErrorZ() { CResult_InvoiceFeaturesDecodeErrorZ_free(self); }
+	CResult_InvoiceFeaturesDecodeErrorZ& operator=(CResult_InvoiceFeaturesDecodeErrorZ&& o) { CResult_InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); return *this; }
+	LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
+};
 class COption_u64Z {
 private:
 	LDKCOption_u64Z self;
@@ -1961,6 +2287,21 @@ public:
 	const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_InvoiceSignOrCreationErrorZ {
+private:
+	LDKCResult_InvoiceSignOrCreationErrorZ self;
+public:
+	CResult_InvoiceSignOrCreationErrorZ(const CResult_InvoiceSignOrCreationErrorZ&) = delete;
+	CResult_InvoiceSignOrCreationErrorZ(CResult_InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); }
+	CResult_InvoiceSignOrCreationErrorZ(LDKCResult_InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); }
+	operator LDKCResult_InvoiceSignOrCreationErrorZ() && { LDKCResult_InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); return res; }
+	~CResult_InvoiceSignOrCreationErrorZ() { CResult_InvoiceSignOrCreationErrorZ_free(self); }
+	CResult_InvoiceSignOrCreationErrorZ& operator=(CResult_InvoiceSignOrCreationErrorZ&& o) { CResult_InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); return *this; }
+	LDKCResult_InvoiceSignOrCreationErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
+};
 class CResult_CommitmentSignedDecodeErrorZ {
 private:
 	LDKCResult_CommitmentSignedDecodeErrorZ self;
@@ -2036,6 +2377,36 @@ public:
 	const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_ExpiryTimeCreationErrorZ {
+private:
+	LDKCResult_ExpiryTimeCreationErrorZ self;
+public:
+	CResult_ExpiryTimeCreationErrorZ(const CResult_ExpiryTimeCreationErrorZ&) = delete;
+	CResult_ExpiryTimeCreationErrorZ(CResult_ExpiryTimeCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ExpiryTimeCreationErrorZ)); }
+	CResult_ExpiryTimeCreationErrorZ(LDKCResult_ExpiryTimeCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ExpiryTimeCreationErrorZ)); }
+	operator LDKCResult_ExpiryTimeCreationErrorZ() && { LDKCResult_ExpiryTimeCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ExpiryTimeCreationErrorZ)); return res; }
+	~CResult_ExpiryTimeCreationErrorZ() { CResult_ExpiryTimeCreationErrorZ_free(self); }
+	CResult_ExpiryTimeCreationErrorZ& operator=(CResult_ExpiryTimeCreationErrorZ&& o) { CResult_ExpiryTimeCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ExpiryTimeCreationErrorZ)); return *this; }
+	LDKCResult_ExpiryTimeCreationErrorZ* operator &() { return &self; }
+	LDKCResult_ExpiryTimeCreationErrorZ* operator ->() { return &self; }
+	const LDKCResult_ExpiryTimeCreationErrorZ* operator &() const { return &self; }
+	const LDKCResult_ExpiryTimeCreationErrorZ* operator ->() const { return &self; }
+};
+class CResult_SignedRawInvoiceNoneZ {
+private:
+	LDKCResult_SignedRawInvoiceNoneZ self;
+public:
+	CResult_SignedRawInvoiceNoneZ(const CResult_SignedRawInvoiceNoneZ&) = delete;
+	CResult_SignedRawInvoiceNoneZ(CResult_SignedRawInvoiceNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawInvoiceNoneZ)); }
+	CResult_SignedRawInvoiceNoneZ(LDKCResult_SignedRawInvoiceNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawInvoiceNoneZ)); }
+	operator LDKCResult_SignedRawInvoiceNoneZ() && { LDKCResult_SignedRawInvoiceNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawInvoiceNoneZ)); return res; }
+	~CResult_SignedRawInvoiceNoneZ() { CResult_SignedRawInvoiceNoneZ_free(self); }
+	CResult_SignedRawInvoiceNoneZ& operator=(CResult_SignedRawInvoiceNoneZ&& o) { CResult_SignedRawInvoiceNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawInvoiceNoneZ)); return *this; }
+	LDKCResult_SignedRawInvoiceNoneZ* operator &() { return &self; }
+	LDKCResult_SignedRawInvoiceNoneZ* operator ->() { return &self; }
+	const LDKCResult_SignedRawInvoiceNoneZ* operator &() const { return &self; }
+	const LDKCResult_SignedRawInvoiceNoneZ* operator ->() const { return &self; }
+};
 class COption_C2Tuple_usizeTransactionZZ {
 private:
 	LDKCOption_C2Tuple_usizeTransactionZZ self;
@@ -2051,21 +2422,6 @@ public:
 	const LDKCOption_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
 	const LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
 };
-class CResult_TransactionNoneZ {
-private:
-	LDKCResult_TransactionNoneZ self;
-public:
-	CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
-	CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
-	CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
-	operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
-	~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
-	CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
-	LDKCResult_TransactionNoneZ* operator &() { return &self; }
-	LDKCResult_TransactionNoneZ* operator ->() { return &self; }
-	const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
-	const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
-};
 class CResult_PingDecodeErrorZ {
 private:
 	LDKCResult_PingDecodeErrorZ self;
@@ -2081,6 +2437,21 @@ public:
 	const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_TransactionNoneZ {
+private:
+	LDKCResult_TransactionNoneZ self;
+public:
+	CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
+	CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
+	CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
+	operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
+	~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
+	CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
+	LDKCResult_TransactionNoneZ* operator &() { return &self; }
+	LDKCResult_TransactionNoneZ* operator ->() { return &self; }
+	const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
+	const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
+};
 class CVec_TransactionOutputsZ {
 private:
 	LDKCVec_TransactionOutputsZ self;
@@ -2156,6 +2527,21 @@ public:
 	const LDKCResult_SecretKeyErrorZ* operator &() const { return &self; }
 	const LDKCResult_SecretKeyErrorZ* operator ->() const { return &self; }
 };
+class CResult_InvoiceNoneZ {
+private:
+	LDKCResult_InvoiceNoneZ self;
+public:
+	CResult_InvoiceNoneZ(const CResult_InvoiceNoneZ&) = delete;
+	CResult_InvoiceNoneZ(CResult_InvoiceNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceNoneZ)); }
+	CResult_InvoiceNoneZ(LDKCResult_InvoiceNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceNoneZ)); }
+	operator LDKCResult_InvoiceNoneZ() && { LDKCResult_InvoiceNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceNoneZ)); return res; }
+	~CResult_InvoiceNoneZ() { CResult_InvoiceNoneZ_free(self); }
+	CResult_InvoiceNoneZ& operator=(CResult_InvoiceNoneZ&& o) { CResult_InvoiceNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceNoneZ)); return *this; }
+	LDKCResult_InvoiceNoneZ* operator &() { return &self; }
+	LDKCResult_InvoiceNoneZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceNoneZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceNoneZ* operator ->() const { return &self; }
+};
 class CResult_QueryChannelRangeDecodeErrorZ {
 private:
 	LDKCResult_QueryChannelRangeDecodeErrorZ self;
@@ -2171,21 +2557,6 @@ public:
 	const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_TransactionZ {
-private:
-	LDKCVec_TransactionZ self;
-public:
-	CVec_TransactionZ(const CVec_TransactionZ&) = delete;
-	CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
-	CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
-	operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
-	~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
-	CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
-	LDKCVec_TransactionZ* operator &() { return &self; }
-	LDKCVec_TransactionZ* operator ->() { return &self; }
-	const LDKCVec_TransactionZ* operator &() const { return &self; }
-	const LDKCVec_TransactionZ* operator ->() const { return &self; }
-};
 class CResult_TxCreationKeysDecodeErrorZ {
 private:
 	LDKCResult_TxCreationKeysDecodeErrorZ self;
@@ -2201,20 +2572,20 @@ public:
 	const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_ChannelFeaturesDecodeErrorZ {
+class CVec_TransactionZ {
 private:
-	LDKCResult_ChannelFeaturesDecodeErrorZ self;
+	LDKCVec_TransactionZ self;
 public:
-	CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
-	CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
-	CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
-	operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
-	~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
-	CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
-	LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
+	CVec_TransactionZ(const CVec_TransactionZ&) = delete;
+	CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
+	CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
+	operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
+	~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
+	CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
+	LDKCVec_TransactionZ* operator &() { return &self; }
+	LDKCVec_TransactionZ* operator ->() { return &self; }
+	const LDKCVec_TransactionZ* operator &() const { return &self; }
+	const LDKCVec_TransactionZ* operator ->() const { return &self; }
 };
 class C2Tuple_usizeTransactionZ {
 private:
@@ -2231,20 +2602,35 @@ public:
 	const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
 	const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
 };
-class CVec_ChannelMonitorZ {
+class CResult_ChannelFeaturesDecodeErrorZ {
 private:
-	LDKCVec_ChannelMonitorZ self;
+	LDKCResult_ChannelFeaturesDecodeErrorZ self;
 public:
-	CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
-	CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
-	CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
-	operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
-	~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
-	CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
-	LDKCVec_ChannelMonitorZ* operator &() { return &self; }
-	LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
-	const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
-	const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
+	CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
+	CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
+	CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
+	operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
+	~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
+	CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_NodeAnnouncementDecodeErrorZ {
+private:
+	LDKCResult_NodeAnnouncementDecodeErrorZ self;
+public:
+	CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
+	CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
+	CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
+	operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
+	~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
+	CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
+	LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_UpdateFeeDecodeErrorZ {
 private:
@@ -2261,20 +2647,20 @@ public:
 	const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_NodeAnnouncementDecodeErrorZ {
+class CVec_ChannelMonitorZ {
 private:
-	LDKCResult_NodeAnnouncementDecodeErrorZ self;
+	LDKCVec_ChannelMonitorZ self;
 public:
-	CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
-	CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
-	CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
-	operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
-	~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
-	CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
-	LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
+	CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
+	CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
+	CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
+	operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
+	~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
+	CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
+	LDKCVec_ChannelMonitorZ* operator &() { return &self; }
+	LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
+	const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
+	const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
 };
 class CResult_HTLCOutputInCommitmentDecodeErrorZ {
 private:
@@ -2366,6 +2752,21 @@ public:
 	const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_RecoverableSignatureNoneZ {
+private:
+	LDKCResult_RecoverableSignatureNoneZ self;
+public:
+	CResult_RecoverableSignatureNoneZ(const CResult_RecoverableSignatureNoneZ&) = delete;
+	CResult_RecoverableSignatureNoneZ(CResult_RecoverableSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); }
+	CResult_RecoverableSignatureNoneZ(LDKCResult_RecoverableSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); }
+	operator LDKCResult_RecoverableSignatureNoneZ() && { LDKCResult_RecoverableSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); return res; }
+	~CResult_RecoverableSignatureNoneZ() { CResult_RecoverableSignatureNoneZ_free(self); }
+	CResult_RecoverableSignatureNoneZ& operator=(CResult_RecoverableSignatureNoneZ&& o) { CResult_RecoverableSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); return *this; }
+	LDKCResult_RecoverableSignatureNoneZ* operator &() { return &self; }
+	LDKCResult_RecoverableSignatureNoneZ* operator ->() { return &self; }
+	const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
+	const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
+};
 class CResult_NetAddressu8Z {
 private:
 	LDKCResult_NetAddressu8Z self;
@@ -2396,6 +2797,21 @@ public:
 	const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
 	const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
 };
+class C3Tuple_RawInvoice_u832InvoiceSignatureZ {
+private:
+	LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ self;
+public:
+	C3Tuple_RawInvoice_u832InvoiceSignatureZ(const C3Tuple_RawInvoice_u832InvoiceSignatureZ&) = delete;
+	C3Tuple_RawInvoice_u832InvoiceSignatureZ(C3Tuple_RawInvoice_u832InvoiceSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_RawInvoice_u832InvoiceSignatureZ)); }
+	C3Tuple_RawInvoice_u832InvoiceSignatureZ(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ)); }
+	operator LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ() && { LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ)); return res; }
+	~C3Tuple_RawInvoice_u832InvoiceSignatureZ() { C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(self); }
+	C3Tuple_RawInvoice_u832InvoiceSignatureZ& operator=(C3Tuple_RawInvoice_u832InvoiceSignatureZ&& o) { C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_RawInvoice_u832InvoiceSignatureZ)); return *this; }
+	LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator &() { return &self; }
+	LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator ->() { return &self; }
+	const LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator &() const { return &self; }
+	const LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator ->() const { return &self; }
+};
 class CResult_NetworkGraphDecodeErrorZ {
 private:
 	LDKCResult_NetworkGraphDecodeErrorZ self;
@@ -2426,6 +2842,21 @@ public:
 	const LDKCVec_RouteHopZ* operator &() const { return &self; }
 	const LDKCVec_RouteHopZ* operator ->() const { return &self; }
 };
+class CResult_RouteHintCreationErrorZ {
+private:
+	LDKCResult_RouteHintCreationErrorZ self;
+public:
+	CResult_RouteHintCreationErrorZ(const CResult_RouteHintCreationErrorZ&) = delete;
+	CResult_RouteHintCreationErrorZ(CResult_RouteHintCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintCreationErrorZ)); }
+	CResult_RouteHintCreationErrorZ(LDKCResult_RouteHintCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintCreationErrorZ)); }
+	operator LDKCResult_RouteHintCreationErrorZ() && { LDKCResult_RouteHintCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintCreationErrorZ)); return res; }
+	~CResult_RouteHintCreationErrorZ() { CResult_RouteHintCreationErrorZ_free(self); }
+	CResult_RouteHintCreationErrorZ& operator=(CResult_RouteHintCreationErrorZ&& o) { CResult_RouteHintCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintCreationErrorZ)); return *this; }
+	LDKCResult_RouteHintCreationErrorZ* operator &() { return &self; }
+	LDKCResult_RouteHintCreationErrorZ* operator ->() { return &self; }
+	const LDKCResult_RouteHintCreationErrorZ* operator &() const { return &self; }
+	const LDKCResult_RouteHintCreationErrorZ* operator ->() const { return &self; }
+};
 class CResult_NodeInfoDecodeErrorZ {
 private:
 	LDKCResult_NodeInfoDecodeErrorZ self;
@@ -2441,20 +2872,20 @@ public:
 	const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_NonePaymentSendFailureZ {
+class CVec_C2Tuple_BlockHashChannelMonitorZZ {
 private:
-	LDKCResult_NonePaymentSendFailureZ self;
+	LDKCVec_C2Tuple_BlockHashChannelMonitorZZ self;
 public:
-	CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
-	CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
-	CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
-	operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
-	~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
-	CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
-	LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
-	LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
-	const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
-	const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
+	CVec_C2Tuple_BlockHashChannelMonitorZZ(const CVec_C2Tuple_BlockHashChannelMonitorZZ&) = delete;
+	CVec_C2Tuple_BlockHashChannelMonitorZZ(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); }
+	CVec_C2Tuple_BlockHashChannelMonitorZZ(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); }
+	operator LDKCVec_C2Tuple_BlockHashChannelMonitorZZ() && { LDKCVec_C2Tuple_BlockHashChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); return res; }
+	~CVec_C2Tuple_BlockHashChannelMonitorZZ() { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); }
+	CVec_C2Tuple_BlockHashChannelMonitorZZ& operator=(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); return *this; }
+	LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() const { return &self; }
 };
 class CVec_u8Z {
 private:
@@ -2501,6 +2932,21 @@ public:
 	const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
 	const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
 };
+class CResult_NonePaymentSendFailureZ {
+private:
+	LDKCResult_NonePaymentSendFailureZ self;
+public:
+	CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
+	CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
+	CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
+	operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
+	~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
+	CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
+	LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
+	LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
+	const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
+	const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
+};
 class CResult_ClosingSignedDecodeErrorZ {
 private:
 	LDKCResult_ClosingSignedDecodeErrorZ self;
@@ -2561,6 +3007,21 @@ public:
 	const LDKCResult_SignatureNoneZ* operator &() const { return &self; }
 	const LDKCResult_SignatureNoneZ* operator ->() const { return &self; }
 };
+class CVec_RouteHintHopZ {
+private:
+	LDKCVec_RouteHintHopZ self;
+public:
+	CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
+	CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
+	CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
+	operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
+	~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
+	CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
+	LDKCVec_RouteHintHopZ* operator &() { return &self; }
+	LDKCVec_RouteHintHopZ* operator ->() { return &self; }
+	const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
+	const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
+};
 class C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
 private:
 	LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ self;
@@ -2711,6 +3172,21 @@ public:
 	const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_PongDecodeErrorZ {
+private:
+	LDKCResult_PongDecodeErrorZ self;
+public:
+	CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
+	CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
+	CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
+	operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
+	~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
+	CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
+	LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_TxidZ {
 private:
 	LDKCVec_TxidZ self;
@@ -2741,21 +3217,6 @@ public:
 	const LDKCResult_NoneMonitorUpdateErrorZ* operator &() const { return &self; }
 	const LDKCResult_NoneMonitorUpdateErrorZ* operator ->() const { return &self; }
 };
-class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
-private:
-	LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ self;
-public:
-	CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(const CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&) = delete;
-	CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
-	CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
-	operator LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() && { LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return res; }
-	~CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); }
-	CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ& operator=(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return *this; }
-	LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() { return &self; }
-	LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() { return &self; }
-	const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() const { return &self; }
-	const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() const { return &self; }
-};
 class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
 private:
 	LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
@@ -2771,35 +3232,20 @@ public:
 	const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
 	const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
 };
-class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
-private:
-	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ self;
-public:
-	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&) = delete;
-	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
-	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
-	operator LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return res; }
-	~CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); }
-	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return *this; }
-	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_CVec_CVec_u8ZZNoneZ {
+class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
 private:
-	LDKCResult_CVec_CVec_u8ZZNoneZ self;
+	LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ self;
 public:
-	CResult_CVec_CVec_u8ZZNoneZ(const CResult_CVec_CVec_u8ZZNoneZ&) = delete;
-	CResult_CVec_CVec_u8ZZNoneZ(CResult_CVec_CVec_u8ZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); }
-	CResult_CVec_CVec_u8ZZNoneZ(LDKCResult_CVec_CVec_u8ZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); }
-	operator LDKCResult_CVec_CVec_u8ZZNoneZ() && { LDKCResult_CVec_CVec_u8ZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); return res; }
-	~CResult_CVec_CVec_u8ZZNoneZ() { CResult_CVec_CVec_u8ZZNoneZ_free(self); }
-	CResult_CVec_CVec_u8ZZNoneZ& operator=(CResult_CVec_CVec_u8ZZNoneZ&& o) { CResult_CVec_CVec_u8ZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); return *this; }
-	LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() { return &self; }
-	LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() { return &self; }
-	const LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() const { return &self; }
-	const LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() const { return &self; }
+	CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(const CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&) = delete;
+	CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
+	CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
+	operator LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() && { LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return res; }
+	~CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); }
+	CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ& operator=(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return *this; }
+	LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() const { return &self; }
 };
 class CResult_AcceptChannelDecodeErrorZ {
 private:
@@ -2816,20 +3262,35 @@ public:
 	const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_PongDecodeErrorZ {
+class CResult_CVec_CVec_u8ZZNoneZ {
 private:
-	LDKCResult_PongDecodeErrorZ self;
+	LDKCResult_CVec_CVec_u8ZZNoneZ self;
 public:
-	CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
-	CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
-	CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
-	operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
-	~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
-	CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
-	LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
+	CResult_CVec_CVec_u8ZZNoneZ(const CResult_CVec_CVec_u8ZZNoneZ&) = delete;
+	CResult_CVec_CVec_u8ZZNoneZ(CResult_CVec_CVec_u8ZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); }
+	CResult_CVec_CVec_u8ZZNoneZ(LDKCResult_CVec_CVec_u8ZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); }
+	operator LDKCResult_CVec_CVec_u8ZZNoneZ() && { LDKCResult_CVec_CVec_u8ZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); return res; }
+	~CResult_CVec_CVec_u8ZZNoneZ() { CResult_CVec_CVec_u8ZZNoneZ_free(self); }
+	CResult_CVec_CVec_u8ZZNoneZ& operator=(CResult_CVec_CVec_u8ZZNoneZ&& o) { CResult_CVec_CVec_u8ZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); return *this; }
+	LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() { return &self; }
+	LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() { return &self; }
+	const LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() const { return &self; }
+	const LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() const { return &self; }
+};
+class C2Tuple_PaymentHashPaymentSecretZ {
+private:
+	LDKC2Tuple_PaymentHashPaymentSecretZ self;
+public:
+	C2Tuple_PaymentHashPaymentSecretZ(const C2Tuple_PaymentHashPaymentSecretZ&) = delete;
+	C2Tuple_PaymentHashPaymentSecretZ(C2Tuple_PaymentHashPaymentSecretZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentSecretZ)); }
+	C2Tuple_PaymentHashPaymentSecretZ(LDKC2Tuple_PaymentHashPaymentSecretZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ)); }
+	operator LDKC2Tuple_PaymentHashPaymentSecretZ() && { LDKC2Tuple_PaymentHashPaymentSecretZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ)); return res; }
+	~C2Tuple_PaymentHashPaymentSecretZ() { C2Tuple_PaymentHashPaymentSecretZ_free(self); }
+	C2Tuple_PaymentHashPaymentSecretZ& operator=(C2Tuple_PaymentHashPaymentSecretZ&& o) { C2Tuple_PaymentHashPaymentSecretZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentSecretZ)); return *this; }
+	LDKC2Tuple_PaymentHashPaymentSecretZ* operator &() { return &self; }
+	LDKC2Tuple_PaymentHashPaymentSecretZ* operator ->() { return &self; }
+	const LDKC2Tuple_PaymentHashPaymentSecretZ* operator &() const { return &self; }
+	const LDKC2Tuple_PaymentHashPaymentSecretZ* operator ->() const { return &self; }
 };
 class C2Tuple_BlockHashChannelManagerZ {
 private:
@@ -2861,6 +3322,21 @@ public:
 	const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+private:
+	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ self;
+public:
+	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&) = delete;
+	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
+	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
+	operator LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return res; }
+	~CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); }
+	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return *this; }
+	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_SignatureZ {
 private:
 	LDKCVec_SignatureZ self;
@@ -2891,6 +3367,36 @@ public:
 	const LDKCVec_u64Z* operator &() const { return &self; }
 	const LDKCVec_u64Z* operator ->() const { return &self; }
 };
+class CResult_StringErrorZ {
+private:
+	LDKCResult_StringErrorZ self;
+public:
+	CResult_StringErrorZ(const CResult_StringErrorZ&) = delete;
+	CResult_StringErrorZ(CResult_StringErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StringErrorZ)); }
+	CResult_StringErrorZ(LDKCResult_StringErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StringErrorZ)); }
+	operator LDKCResult_StringErrorZ() && { LDKCResult_StringErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StringErrorZ)); return res; }
+	~CResult_StringErrorZ() { CResult_StringErrorZ_free(self); }
+	CResult_StringErrorZ& operator=(CResult_StringErrorZ&& o) { CResult_StringErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StringErrorZ)); return *this; }
+	LDKCResult_StringErrorZ* operator &() { return &self; }
+	LDKCResult_StringErrorZ* operator ->() { return &self; }
+	const LDKCResult_StringErrorZ* operator &() const { return &self; }
+	const LDKCResult_StringErrorZ* operator ->() const { return &self; }
+};
+class CResult_NoneErrorZ {
+private:
+	LDKCResult_NoneErrorZ self;
+public:
+	CResult_NoneErrorZ(const CResult_NoneErrorZ&) = delete;
+	CResult_NoneErrorZ(CResult_NoneErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneErrorZ)); }
+	CResult_NoneErrorZ(LDKCResult_NoneErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneErrorZ)); }
+	operator LDKCResult_NoneErrorZ() && { LDKCResult_NoneErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneErrorZ)); return res; }
+	~CResult_NoneErrorZ() { CResult_NoneErrorZ_free(self); }
+	CResult_NoneErrorZ& operator=(CResult_NoneErrorZ&& o) { CResult_NoneErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneErrorZ)); return *this; }
+	LDKCResult_NoneErrorZ* operator &() { return &self; }
+	LDKCResult_NoneErrorZ* operator ->() { return &self; }
+	const LDKCResult_NoneErrorZ* operator &() const { return &self; }
+	const LDKCResult_NoneErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
 private:
 	LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ self;
@@ -2996,6 +3502,21 @@ public:
 	const LDKCResult_CVec_SignatureZNoneZ* operator &() const { return &self; }
 	const LDKCResult_CVec_SignatureZNoneZ* operator ->() const { return &self; }
 };
+class CResult_DescriptionCreationErrorZ {
+private:
+	LDKCResult_DescriptionCreationErrorZ self;
+public:
+	CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
+	CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
+	CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
+	operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
+	~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
+	CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
+	LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
+	LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
+	const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
+	const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
+};
 class CResult_RoutingFeesDecodeErrorZ {
 private:
 	LDKCResult_RoutingFeesDecodeErrorZ self;
@@ -3011,6 +3532,21 @@ public:
 	const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_PayeePubKeyErrorZ {
+private:
+	LDKCResult_PayeePubKeyErrorZ self;
+public:
+	CResult_PayeePubKeyErrorZ(const CResult_PayeePubKeyErrorZ&) = delete;
+	CResult_PayeePubKeyErrorZ(CResult_PayeePubKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); }
+	CResult_PayeePubKeyErrorZ(LDKCResult_PayeePubKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); }
+	operator LDKCResult_PayeePubKeyErrorZ() && { LDKCResult_PayeePubKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); return res; }
+	~CResult_PayeePubKeyErrorZ() { CResult_PayeePubKeyErrorZ_free(self); }
+	CResult_PayeePubKeyErrorZ& operator=(CResult_PayeePubKeyErrorZ&& o) { CResult_PayeePubKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); return *this; }
+	LDKCResult_PayeePubKeyErrorZ* operator &() { return &self; }
+	LDKCResult_PayeePubKeyErrorZ* operator ->() { return &self; }
+	const LDKCResult_PayeePubKeyErrorZ* operator &() const { return &self; }
+	const LDKCResult_PayeePubKeyErrorZ* operator ->() const { return &self; }
+};
 class CResult_QueryShortChannelIdsDecodeErrorZ {
 private:
 	LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
@@ -3026,6 +3562,21 @@ public:
 	const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_InvoiceSemanticErrorZ {
+private:
+	LDKCResult_InvoiceSemanticErrorZ self;
+public:
+	CResult_InvoiceSemanticErrorZ(const CResult_InvoiceSemanticErrorZ&) = delete;
+	CResult_InvoiceSemanticErrorZ(CResult_InvoiceSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSemanticErrorZ)); }
+	CResult_InvoiceSemanticErrorZ(LDKCResult_InvoiceSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSemanticErrorZ)); }
+	operator LDKCResult_InvoiceSemanticErrorZ() && { LDKCResult_InvoiceSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSemanticErrorZ)); return res; }
+	~CResult_InvoiceSemanticErrorZ() { CResult_InvoiceSemanticErrorZ_free(self); }
+	CResult_InvoiceSemanticErrorZ& operator=(CResult_InvoiceSemanticErrorZ&& o) { CResult_InvoiceSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSemanticErrorZ)); return *this; }
+	LDKCResult_InvoiceSemanticErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceSemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceSemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceSemanticErrorZ* operator ->() const { return &self; }
+};
 class CResult_UpdateAddHTLCDecodeErrorZ {
 private:
 	LDKCResult_UpdateAddHTLCDecodeErrorZ self;
@@ -3086,21 +3637,6 @@ public:
 	const LDKCVec_NetAddressZ* operator &() const { return &self; }
 	const LDKCVec_NetAddressZ* operator ->() const { return &self; }
 };
-class CVec_PublicKeyZ {
-private:
-	LDKCVec_PublicKeyZ self;
-public:
-	CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
-	CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
-	CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
-	operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
-	~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
-	CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
-	LDKCVec_PublicKeyZ* operator &() { return &self; }
-	LDKCVec_PublicKeyZ* operator ->() { return &self; }
-	const LDKCVec_PublicKeyZ* operator &() const { return &self; }
-	const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
-};
 class CVec_C2Tuple_usizeTransactionZZ {
 private:
 	LDKCVec_C2Tuple_usizeTransactionZZ self;
@@ -3116,6 +3652,21 @@ public:
 	const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
 };
+class CVec_PublicKeyZ {
+private:
+	LDKCVec_PublicKeyZ self;
+public:
+	CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
+	CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
+	CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
+	operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
+	~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
+	CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
+	LDKCVec_PublicKeyZ* operator &() { return &self; }
+	LDKCVec_PublicKeyZ* operator ->() { return &self; }
+	const LDKCVec_PublicKeyZ* operator &() const { return &self; }
+	const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
+};
 class CResult_DirectionalChannelInfoDecodeErrorZ {
 private:
 	LDKCResult_DirectionalChannelInfoDecodeErrorZ self;
@@ -3251,20 +3802,20 @@ public:
 	const LDKCVec_EventZ* operator &() const { return &self; }
 	const LDKCVec_EventZ* operator ->() const { return &self; }
 };
-class CVec_MonitorEventZ {
+class CResult_NoneSemanticErrorZ {
 private:
-	LDKCVec_MonitorEventZ self;
+	LDKCResult_NoneSemanticErrorZ self;
 public:
-	CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete;
-	CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); }
-	CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); }
-	operator LDKCVec_MonitorEventZ() && { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
-	~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
-	CVec_MonitorEventZ& operator=(CVec_MonitorEventZ&& o) { CVec_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorEventZ)); return *this; }
-	LDKCVec_MonitorEventZ* operator &() { return &self; }
-	LDKCVec_MonitorEventZ* operator ->() { return &self; }
-	const LDKCVec_MonitorEventZ* operator &() const { return &self; }
-	const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
+	CResult_NoneSemanticErrorZ(const CResult_NoneSemanticErrorZ&) = delete;
+	CResult_NoneSemanticErrorZ(CResult_NoneSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneSemanticErrorZ)); }
+	CResult_NoneSemanticErrorZ(LDKCResult_NoneSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneSemanticErrorZ)); }
+	operator LDKCResult_NoneSemanticErrorZ() && { LDKCResult_NoneSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneSemanticErrorZ)); return res; }
+	~CResult_NoneSemanticErrorZ() { CResult_NoneSemanticErrorZ_free(self); }
+	CResult_NoneSemanticErrorZ& operator=(CResult_NoneSemanticErrorZ&& o) { CResult_NoneSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneSemanticErrorZ)); return *this; }
+	LDKCResult_NoneSemanticErrorZ* operator &() { return &self; }
+	LDKCResult_NoneSemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_NoneSemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_NoneSemanticErrorZ* operator ->() const { return &self; }
 };
 class CVec_C2Tuple_u32ScriptZZ {
 private:
@@ -3281,6 +3832,21 @@ public:
 	const LDKCVec_C2Tuple_u32ScriptZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_u32ScriptZZ* operator ->() const { return &self; }
 };
+class CVec_MonitorEventZ {
+private:
+	LDKCVec_MonitorEventZ self;
+public:
+	CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete;
+	CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); }
+	CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); }
+	operator LDKCVec_MonitorEventZ() && { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
+	~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
+	CVec_MonitorEventZ& operator=(CVec_MonitorEventZ&& o) { CVec_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorEventZ)); return *this; }
+	LDKCVec_MonitorEventZ* operator &() { return &self; }
+	LDKCVec_MonitorEventZ* operator ->() { return &self; }
+	const LDKCVec_MonitorEventZ* operator &() const { return &self; }
+	const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
+};
 class CResult_NoneChannelMonitorUpdateErrZ {
 private:
 	LDKCResult_NoneChannelMonitorUpdateErrZ self;
@@ -3296,6 +3862,21 @@ public:
 	const LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() const { return &self; }
 	const LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() const { return &self; }
 };
+class CResult_SiPrefixNoneZ {
+private:
+	LDKCResult_SiPrefixNoneZ self;
+public:
+	CResult_SiPrefixNoneZ(const CResult_SiPrefixNoneZ&) = delete;
+	CResult_SiPrefixNoneZ(CResult_SiPrefixNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixNoneZ)); }
+	CResult_SiPrefixNoneZ(LDKCResult_SiPrefixNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixNoneZ)); }
+	operator LDKCResult_SiPrefixNoneZ() && { LDKCResult_SiPrefixNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixNoneZ)); return res; }
+	~CResult_SiPrefixNoneZ() { CResult_SiPrefixNoneZ_free(self); }
+	CResult_SiPrefixNoneZ& operator=(CResult_SiPrefixNoneZ&& o) { CResult_SiPrefixNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixNoneZ)); return *this; }
+	LDKCResult_SiPrefixNoneZ* operator &() { return &self; }
+	LDKCResult_SiPrefixNoneZ* operator ->() { return &self; }
+	const LDKCResult_SiPrefixNoneZ* operator &() const { return &self; }
+	const LDKCResult_SiPrefixNoneZ* operator ->() const { return &self; }
+};
 class CResult_PublicKeyErrorZ {
 private:
 	LDKCResult_PublicKeyErrorZ self;
@@ -3431,21 +4012,6 @@ public:
 	const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_InMemorySignerDecodeErrorZ {
-private:
-	LDKCResult_InMemorySignerDecodeErrorZ self;
-public:
-	CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
-	CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
-	CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
-	operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
-	~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
-	CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
-	LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
 private:
 	LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
@@ -3461,6 +4027,21 @@ public:
 	const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_InMemorySignerDecodeErrorZ {
+private:
+	LDKCResult_InMemorySignerDecodeErrorZ self;
+public:
+	CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
+	CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
+	CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
+	operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
+	~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
+	CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
+	LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_u32ScriptZ {
 private:
 	LDKC2Tuple_u32ScriptZ self;
@@ -3491,6 +4072,21 @@ public:
 	const LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_PaymentSecretAPIErrorZ {
+private:
+	LDKCResult_PaymentSecretAPIErrorZ self;
+public:
+	CResult_PaymentSecretAPIErrorZ(const CResult_PaymentSecretAPIErrorZ&) = delete;
+	CResult_PaymentSecretAPIErrorZ(CResult_PaymentSecretAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentSecretAPIErrorZ)); }
+	CResult_PaymentSecretAPIErrorZ(LDKCResult_PaymentSecretAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentSecretAPIErrorZ)); }
+	operator LDKCResult_PaymentSecretAPIErrorZ() && { LDKCResult_PaymentSecretAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentSecretAPIErrorZ)); return res; }
+	~CResult_PaymentSecretAPIErrorZ() { CResult_PaymentSecretAPIErrorZ_free(self); }
+	CResult_PaymentSecretAPIErrorZ& operator=(CResult_PaymentSecretAPIErrorZ&& o) { CResult_PaymentSecretAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentSecretAPIErrorZ)); return *this; }
+	LDKCResult_PaymentSecretAPIErrorZ* operator &() { return &self; }
+	LDKCResult_PaymentSecretAPIErrorZ* operator ->() { return &self; }
+	const LDKCResult_PaymentSecretAPIErrorZ* operator &() const { return &self; }
+	const LDKCResult_PaymentSecretAPIErrorZ* operator ->() const { return &self; }
+};
 class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
 private:
 	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
@@ -3536,21 +4132,6 @@ public:
 	const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_TxOutZ {
-private:
-	LDKCVec_TxOutZ self;
-public:
-	CVec_TxOutZ(const CVec_TxOutZ&) = delete;
-	CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
-	CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
-	operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
-	~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
-	CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
-	LDKCVec_TxOutZ* operator &() { return &self; }
-	LDKCVec_TxOutZ* operator ->() { return &self; }
-	const LDKCVec_TxOutZ* operator &() const { return &self; }
-	const LDKCVec_TxOutZ* operator ->() const { return &self; }
-};
 class CVec_UpdateFailHTLCZ {
 private:
 	LDKCVec_UpdateFailHTLCZ self;
@@ -3581,4 +4162,19 @@ public:
 	const LDKCResult_FundingLockedDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_FundingLockedDecodeErrorZ* operator ->() const { return &self; }
 };
+class CVec_TxOutZ {
+private:
+	LDKCVec_TxOutZ self;
+public:
+	CVec_TxOutZ(const CVec_TxOutZ&) = delete;
+	CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
+	CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
+	operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
+	~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
+	CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
+	LDKCVec_TxOutZ* operator &() { return &self; }
+	LDKCVec_TxOutZ* operator ->() { return &self; }
+	const LDKCVec_TxOutZ* operator &() const { return &self; }
+	const LDKCVec_TxOutZ* operator ->() const { return &self; }
+};
 }