Regenerate auto-generated bindings

[ldk-c-bindings] / lightning-c-bindings / include / lightningpp.hpp

diff --git a/lightning-c-bindings/include/lightningpp.hpp b/lightning-c-bindings/include/lightningpp.hpp
index 329299004db819c4db8160aacdbea2d5adc0b274..0cd1dc46eac215ad99627517ac615028a8286ea7 100644 (file)
--- a/lightning-c-bindings/include/lightningpp.hpp
+++ b/lightning-c-bindings/include/lightningpp.hpp
@@ -1,95 +1,5 @@
 #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;
-public:
-       APIError(const APIError&) = delete;
-       APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
-       APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
-       operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
-       ~APIError() { APIError_free(self); }
-       APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
-       LDKAPIError* operator &() { return &self; }
-       LDKAPIError* operator ->() { return &self; }
-       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;
@@ -240,733 +150,1138 @@ public:
        const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
        const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
 };
-class Invoice {
+class BackgroundProcessor {
 private:
-       LDKInvoice self;
+       LDKBackgroundProcessor 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; }
+       BackgroundProcessor(const BackgroundProcessor&) = delete;
+       BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
+       BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
+       operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
+       ~BackgroundProcessor() { BackgroundProcessor_free(self); }
+       BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
+       LDKBackgroundProcessor* operator &() { return &self; }
+       LDKBackgroundProcessor* operator ->() { return &self; }
+       const LDKBackgroundProcessor* operator &() const { return &self; }
+       const LDKBackgroundProcessor* operator ->() const { return &self; }
 };
-class SignedRawInvoice {
+class ChannelManagerPersister {
 private:
-       LDKSignedRawInvoice self;
+       LDKChannelManagerPersister 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; }
+       ChannelManagerPersister(const ChannelManagerPersister&) = delete;
+       ChannelManagerPersister(ChannelManagerPersister&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerPersister)); }
+       ChannelManagerPersister(LDKChannelManagerPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerPersister)); }
+       operator LDKChannelManagerPersister() && { LDKChannelManagerPersister res = self; memset(&self, 0, sizeof(LDKChannelManagerPersister)); return res; }
+       ~ChannelManagerPersister() { ChannelManagerPersister_free(self); }
+       ChannelManagerPersister& operator=(ChannelManagerPersister&& o) { ChannelManagerPersister_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerPersister)); return *this; }
+       LDKChannelManagerPersister* operator &() { return &self; }
+       LDKChannelManagerPersister* operator ->() { return &self; }
+       const LDKChannelManagerPersister* operator &() const { return &self; }
+       const LDKChannelManagerPersister* operator ->() const { return &self; }
 };
-class RawInvoice {
+class RouteHop {
 private:
-       LDKRawInvoice self;
+       LDKRouteHop 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; }
+       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 RawDataPart {
+class Route {
 private:
-       LDKRawDataPart self;
+       LDKRoute 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; }
+       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 PositiveTimestamp {
+class RouteHintHop {
 private:
-       LDKPositiveTimestamp self;
+       LDKRouteHintHop 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; }
+       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 SiPrefix {
+class BroadcasterInterface {
 private:
-       LDKSiPrefix self;
+       LDKBroadcasterInterface 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; }
+       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 Currency {
+class ConfirmationTarget {
 private:
-       LDKCurrency self;
+       LDKConfirmationTarget 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; }
+       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 Sha256 {
+class FeeEstimator {
 private:
-       LDKSha256 self;
+       LDKFeeEstimator 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; }
+       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 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 {
+class AccessError {
 private:
-       LDKPayeePubKey self;
+       LDKAccessError 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; }
+       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 ExpiryTime {
+class Access {
 private:
-       LDKExpiryTime self;
+       LDKAccess 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; }
+       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 MinFinalCltvExpiry {
+class Listen {
 private:
-       LDKMinFinalCltvExpiry self;
+       LDKListen 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; }
+       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 Fallback {
+class Confirm {
 private:
-       LDKFallback self;
+       LDKConfirm 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; }
+       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 InvoiceSignature {
+class Watch {
 private:
-       LDKInvoiceSignature self;
+       LDKWatch 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; }
+       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 RouteHint {
+class Filter {
 private:
-       LDKRouteHint self;
+       LDKFilter 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; }
+       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 CreationError {
+class WatchedOutput {
 private:
-       LDKCreationError self;
+       LDKWatchedOutput 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; }
+       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 SemanticError {
+class Event {
 private:
-       LDKSemanticError self;
+       LDKEvent 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; }
+       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 SignOrCreationError {
+class MessageSendEvent {
 private:
-       LDKSignOrCreationError self;
+       LDKMessageSendEvent 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; }
+       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 ChannelMonitorUpdate {
+class MessageSendEventsProvider {
 private:
-       LDKChannelMonitorUpdate self;
+       LDKMessageSendEventsProvider 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; }
+       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 ChannelMonitorUpdateErr {
+class EventsProvider {
 private:
-       LDKChannelMonitorUpdateErr self;
+       LDKEventsProvider 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; }
+       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 EventHandler {
+private:
+       LDKEventHandler self;
+public:
+       EventHandler(const EventHandler&) = delete;
+       EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
+       EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
+       operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
+       ~EventHandler() { EventHandler_free(self); }
+       EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
+       LDKEventHandler* operator &() { return &self; }
+       LDKEventHandler* operator ->() { return &self; }
+       const LDKEventHandler* operator &() const { return &self; }
+       const LDKEventHandler* operator ->() const { return &self; }
+};
+class InitFeatures {
+private:
+       LDKInitFeatures 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; }
+};
+class NodeFeatures {
+private:
+       LDKNodeFeatures 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; }
+};
+class ChannelFeatures {
+private:
+       LDKChannelFeatures 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; }
+};
+class InvoiceFeatures {
+private:
+       LDKInvoiceFeatures 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; }
+};
+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;
+       BaseSign(BaseSign&& o) : self(o.self) { memset(&o, 0, sizeof(BaseSign)); }
+       BaseSign(LDKBaseSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBaseSign)); }
+       operator LDKBaseSign() && { LDKBaseSign res = self; memset(&self, 0, sizeof(LDKBaseSign)); return res; }
+       ~BaseSign() { BaseSign_free(self); }
+       BaseSign& operator=(BaseSign&& o) { BaseSign_free(self); self = o.self; memset(&o, 0, sizeof(BaseSign)); return *this; }
+       LDKBaseSign* operator &() { return &self; }
+       LDKBaseSign* operator ->() { return &self; }
+       const LDKBaseSign* operator &() const { return &self; }
+       const LDKBaseSign* operator ->() const { return &self; }
+};
+class Sign {
+private:
+       LDKSign self;
+public:
+       Sign(const Sign&) = delete;
+       Sign(Sign&& o) : self(o.self) { memset(&o, 0, sizeof(Sign)); }
+       Sign(LDKSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSign)); }
+       operator LDKSign() && { LDKSign res = self; memset(&self, 0, sizeof(LDKSign)); return res; }
+       ~Sign() { Sign_free(self); }
+       Sign& operator=(Sign&& o) { Sign_free(self); self = o.self; memset(&o, 0, sizeof(Sign)); return *this; }
+       LDKSign* operator &() { return &self; }
+       LDKSign* operator ->() { return &self; }
+       const LDKSign* operator &() const { return &self; }
+       const LDKSign* operator ->() const { return &self; }
+};
+class KeysInterface {
+private:
+       LDKKeysInterface self;
+public:
+       KeysInterface(const KeysInterface&) = delete;
+       KeysInterface(KeysInterface&& o) : self(o.self) { memset(&o, 0, sizeof(KeysInterface)); }
+       KeysInterface(LDKKeysInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysInterface)); }
+       operator LDKKeysInterface() && { LDKKeysInterface res = self; memset(&self, 0, sizeof(LDKKeysInterface)); return res; }
+       ~KeysInterface() { KeysInterface_free(self); }
+       KeysInterface& operator=(KeysInterface&& o) { KeysInterface_free(self); self = o.self; memset(&o, 0, sizeof(KeysInterface)); return *this; }
+       LDKKeysInterface* operator &() { return &self; }
+       LDKKeysInterface* operator ->() { return &self; }
+       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 FilesystemPersister {
+private:
+       LDKFilesystemPersister self;
+public:
+       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 ChannelManager {
+private:
+       LDKChannelManager 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; }
+};
+class ChainParameters {
+private:
+       LDKChainParameters 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; }
+};
+class BestBlock {
+private:
+       LDKBestBlock 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; }
+};
+class ChannelDetails {
+private:
+       LDKChannelDetails 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; }
+};
+class PaymentSendFailure {
+private:
+       LDKPaymentSendFailure 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; }
+};
+class ChannelManagerReadArgs {
+private:
+       LDKChannelManagerReadArgs 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; }
+};
+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;
+public:
+       APIError(const APIError&) = delete;
+       APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
+       APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
+       operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
+       ~APIError() { APIError_free(self); }
+       APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
+       LDKAPIError* operator &() { return &self; }
+       LDKAPIError* operator ->() { return &self; }
+       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 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 MonitorUpdateError {
+class RawInvoice {
 private:
-       LDKMonitorUpdateError self;
+       LDKRawInvoice 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; }
+       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 MonitorEvent {
+class RawDataPart {
 private:
-       LDKMonitorEvent self;
+       LDKRawDataPart 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; }
+       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 HTLCUpdate {
+class PositiveTimestamp {
 private:
-       LDKHTLCUpdate self;
+       LDKPositiveTimestamp 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; }
+       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 ChannelMonitor {
+class SiPrefix {
 private:
-       LDKChannelMonitor self;
+       LDKSiPrefix 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; }
+       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 Persist {
+class Currency {
 private:
-       LDKPersist self;
+       LDKCurrency 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; }
+       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 RouteHop {
+class Sha256 {
 private:
-       LDKRouteHop self;
+       LDKSha256 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; }
+       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 Route {
+class Description {
 private:
-       LDKRoute self;
+       LDKDescription 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; }
+       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 RouteHintHop {
+class PayeePubKey {
 private:
-       LDKRouteHintHop self;
+       LDKPayeePubKey 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; }
+       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 IgnoringMessageHandler {
+class ExpiryTime {
 private:
-       LDKIgnoringMessageHandler self;
+       LDKExpiryTime self;
 public:
-       IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
-       IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
-       IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
-       operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
-       ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
-       IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
-       LDKIgnoringMessageHandler* operator &() { return &self; }
-       LDKIgnoringMessageHandler* operator ->() { return &self; }
-       const LDKIgnoringMessageHandler* operator &() const { return &self; }
-       const LDKIgnoringMessageHandler* operator ->() const { return &self; }
+       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 ErroringMessageHandler {
+class MinFinalCltvExpiry {
 private:
-       LDKErroringMessageHandler self;
+       LDKMinFinalCltvExpiry self;
 public:
-       ErroringMessageHandler(const ErroringMessageHandler&) = delete;
-       ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
-       ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
-       operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
-       ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
-       ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
-       LDKErroringMessageHandler* operator &() { return &self; }
-       LDKErroringMessageHandler* operator ->() { return &self; }
-       const LDKErroringMessageHandler* operator &() const { return &self; }
-       const LDKErroringMessageHandler* operator ->() const { return &self; }
+       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 MessageHandler {
+class Fallback {
 private:
-       LDKMessageHandler self;
+       LDKFallback self;
 public:
-       MessageHandler(const MessageHandler&) = delete;
-       MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
-       MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
-       operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
-       ~MessageHandler() { MessageHandler_free(self); }
-       MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
-       LDKMessageHandler* operator &() { return &self; }
-       LDKMessageHandler* operator ->() { return &self; }
-       const LDKMessageHandler* operator &() const { return &self; }
-       const LDKMessageHandler* operator ->() const { return &self; }
+       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 SocketDescriptor {
+class InvoiceSignature {
 private:
-       LDKSocketDescriptor self;
+       LDKInvoiceSignature self;
 public:
-       SocketDescriptor(const SocketDescriptor&) = delete;
-       SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
-       SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
-       operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
-       ~SocketDescriptor() { SocketDescriptor_free(self); }
-       SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
-       LDKSocketDescriptor* operator &() { return &self; }
-       LDKSocketDescriptor* operator ->() { return &self; }
-       const LDKSocketDescriptor* operator &() const { return &self; }
-       const LDKSocketDescriptor* operator ->() const { return &self; }
+       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 PeerHandleError {
+class RouteHint {
 private:
-       LDKPeerHandleError self;
+       LDKRouteHint self;
 public:
-       PeerHandleError(const PeerHandleError&) = delete;
-       PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
-       PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
-       operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
-       ~PeerHandleError() { PeerHandleError_free(self); }
-       PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
-       LDKPeerHandleError* operator &() { return &self; }
-       LDKPeerHandleError* operator ->() { return &self; }
-       const LDKPeerHandleError* operator &() const { return &self; }
-       const LDKPeerHandleError* operator ->() const { return &self; }
+       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 PeerManager {
+class CreationError {
 private:
-       LDKPeerManager self;
+       LDKCreationError self;
 public:
-       PeerManager(const PeerManager&) = delete;
-       PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
-       PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
-       operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
-       ~PeerManager() { PeerManager_free(self); }
-       PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
-       LDKPeerManager* operator &() { return &self; }
-       LDKPeerManager* operator ->() { return &self; }
-       const LDKPeerManager* operator &() const { return &self; }
-       const LDKPeerManager* operator ->() const { return &self; }
+       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 BroadcasterInterface {
+class SemanticError {
 private:
-       LDKBroadcasterInterface self;
+       LDKSemanticError 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; }
+       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 ConfirmationTarget {
+class SignOrCreationError {
 private:
-       LDKConfirmationTarget self;
+       LDKSignOrCreationError 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; }
+       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 FeeEstimator {
+class ChannelMonitorUpdate {
 private:
-       LDKFeeEstimator self;
+       LDKChannelMonitorUpdate 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; }
+       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 AccessError {
+class ChannelMonitorUpdateErr {
 private:
-       LDKAccessError self;
+       LDKChannelMonitorUpdateErr 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; }
+       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 Access {
+class MonitorUpdateError {
 private:
-       LDKAccess self;
+       LDKMonitorUpdateError 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; }
+       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 Listen {
+class MonitorEvent {
 private:
-       LDKListen self;
+       LDKMonitorEvent 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; }
+       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 Confirm {
+class HTLCUpdate {
 private:
-       LDKConfirm self;
+       LDKHTLCUpdate self;
 public:
-       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; }
+       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 Watch {
+class ChannelMonitor {
 private:
-       LDKWatch 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; }
+       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 Filter {
+class Persist {
 private:
-       LDKFilter self;
+       LDKPersist 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; }
+       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 WatchedOutput {
+class IgnoringMessageHandler {
 private:
-       LDKWatchedOutput self;
+       LDKIgnoringMessageHandler 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; }
+       IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
+       IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
+       IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
+       operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
+       ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
+       IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
+       LDKIgnoringMessageHandler* operator &() { return &self; }
+       LDKIgnoringMessageHandler* operator ->() { return &self; }
+       const LDKIgnoringMessageHandler* operator &() const { return &self; }
+       const LDKIgnoringMessageHandler* operator ->() const { return &self; }
 };
-class Event {
+class ErroringMessageHandler {
 private:
-       LDKEvent self;
+       LDKErroringMessageHandler 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; }
+       ErroringMessageHandler(const ErroringMessageHandler&) = delete;
+       ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
+       ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
+       operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
+       ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
+       ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
+       LDKErroringMessageHandler* operator &() { return &self; }
+       LDKErroringMessageHandler* operator ->() { return &self; }
+       const LDKErroringMessageHandler* operator &() const { return &self; }
+       const LDKErroringMessageHandler* operator ->() const { return &self; }
 };
-class MessageSendEvent {
+class MessageHandler {
 private:
-       LDKMessageSendEvent self;
+       LDKMessageHandler 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; }
+       MessageHandler(const MessageHandler&) = delete;
+       MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
+       MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
+       operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
+       ~MessageHandler() { MessageHandler_free(self); }
+       MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
+       LDKMessageHandler* operator &() { return &self; }
+       LDKMessageHandler* operator ->() { return &self; }
+       const LDKMessageHandler* operator &() const { return &self; }
+       const LDKMessageHandler* operator ->() const { return &self; }
 };
-class MessageSendEventsProvider {
+class SocketDescriptor {
 private:
-       LDKMessageSendEventsProvider self;
+       LDKSocketDescriptor 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; }
+       SocketDescriptor(const SocketDescriptor&) = delete;
+       SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
+       SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
+       operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
+       ~SocketDescriptor() { SocketDescriptor_free(self); }
+       SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
+       LDKSocketDescriptor* operator &() { return &self; }
+       LDKSocketDescriptor* operator ->() { return &self; }
+       const LDKSocketDescriptor* operator &() const { return &self; }
+       const LDKSocketDescriptor* operator ->() const { return &self; }
 };
-class EventsProvider {
+class PeerHandleError {
 private:
-       LDKEventsProvider self;
+       LDKPeerHandleError 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; }
+       PeerHandleError(const PeerHandleError&) = delete;
+       PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
+       PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
+       operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
+       ~PeerHandleError() { PeerHandleError_free(self); }
+       PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
+       LDKPeerHandleError* operator &() { return &self; }
+       LDKPeerHandleError* operator ->() { return &self; }
+       const LDKPeerHandleError* operator &() const { return &self; }
+       const LDKPeerHandleError* operator ->() const { return &self; }
 };
-class EventHandler {
+class PeerManager {
 private:
-       LDKEventHandler self;
+       LDKPeerManager self;
 public:
-       EventHandler(const EventHandler&) = delete;
-       EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
-       EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
-       operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
-       ~EventHandler() { EventHandler_free(self); }
-       EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
-       LDKEventHandler* operator &() { return &self; }
-       LDKEventHandler* operator ->() { return &self; }
-       const LDKEventHandler* operator &() const { return &self; }
-       const LDKEventHandler* operator ->() const { return &self; }
+       PeerManager(const PeerManager&) = delete;
+       PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
+       PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
+       operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
+       ~PeerManager() { PeerManager_free(self); }
+       PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
+       LDKPeerManager* operator &() { return &self; }
+       LDKPeerManager* operator ->() { return &self; }
+       const LDKPeerManager* operator &() const { return &self; }
+       const LDKPeerManager* operator ->() const { return &self; }
 };
 class NetworkGraph {
 private:
@@ -1070,83 +1385,23 @@ public:
        NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
        LDKNodeAnnouncementInfo* operator &() { return &self; }
        LDKNodeAnnouncementInfo* operator ->() { return &self; }
-       const LDKNodeAnnouncementInfo* operator &() const { return &self; }
-       const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
-};
-class NodeInfo {
-private:
-       LDKNodeInfo self;
-public:
-       NodeInfo(const NodeInfo&) = delete;
-       NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
-       NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
-       operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
-       ~NodeInfo() { NodeInfo_free(self); }
-       NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
-       LDKNodeInfo* operator &() { return &self; }
-       LDKNodeInfo* operator ->() { return &self; }
-       const LDKNodeInfo* operator &() const { return &self; }
-       const LDKNodeInfo* operator ->() const { return &self; }
-};
-class InitFeatures {
-private:
-       LDKInitFeatures 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; }
-};
-class NodeFeatures {
-private:
-       LDKNodeFeatures 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; }
-};
-class ChannelFeatures {
-private:
-       LDKChannelFeatures 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; }
-};
-class InvoiceFeatures {
-private:
-       LDKInvoiceFeatures 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; }
+       const LDKNodeAnnouncementInfo* operator &() const { return &self; }
+       const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
+};
+class NodeInfo {
+private:
+       LDKNodeInfo self;
+public:
+       NodeInfo(const NodeInfo&) = delete;
+       NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
+       NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
+       operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
+       ~NodeInfo() { NodeInfo_free(self); }
+       NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
+       LDKNodeInfo* operator &() { return &self; }
+       LDKNodeInfo* operator ->() { return &self; }
+       const LDKNodeInfo* operator &() const { return &self; }
+       const LDKNodeInfo* operator ->() const { return &self; }
 };
 class DecodeError {
 private:
@@ -1777,245 +2032,20 @@ public:
        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;
-       BaseSign(BaseSign&& o) : self(o.self) { memset(&o, 0, sizeof(BaseSign)); }
-       BaseSign(LDKBaseSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBaseSign)); }
-       operator LDKBaseSign() && { LDKBaseSign res = self; memset(&self, 0, sizeof(LDKBaseSign)); return res; }
-       ~BaseSign() { BaseSign_free(self); }
-       BaseSign& operator=(BaseSign&& o) { BaseSign_free(self); self = o.self; memset(&o, 0, sizeof(BaseSign)); return *this; }
-       LDKBaseSign* operator &() { return &self; }
-       LDKBaseSign* operator ->() { return &self; }
-       const LDKBaseSign* operator &() const { return &self; }
-       const LDKBaseSign* operator ->() const { return &self; }
-};
-class Sign {
-private:
-       LDKSign self;
-public:
-       Sign(const Sign&) = delete;
-       Sign(Sign&& o) : self(o.self) { memset(&o, 0, sizeof(Sign)); }
-       Sign(LDKSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSign)); }
-       operator LDKSign() && { LDKSign res = self; memset(&self, 0, sizeof(LDKSign)); return res; }
-       ~Sign() { Sign_free(self); }
-       Sign& operator=(Sign&& o) { Sign_free(self); self = o.self; memset(&o, 0, sizeof(Sign)); return *this; }
-       LDKSign* operator &() { return &self; }
-       LDKSign* operator ->() { return &self; }
-       const LDKSign* operator &() const { return &self; }
-       const LDKSign* operator ->() const { return &self; }
-};
-class KeysInterface {
-private:
-       LDKKeysInterface self;
-public:
-       KeysInterface(const KeysInterface&) = delete;
-       KeysInterface(KeysInterface&& o) : self(o.self) { memset(&o, 0, sizeof(KeysInterface)); }
-       KeysInterface(LDKKeysInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysInterface)); }
-       operator LDKKeysInterface() && { LDKKeysInterface res = self; memset(&self, 0, sizeof(LDKKeysInterface)); return res; }
-       ~KeysInterface() { KeysInterface_free(self); }
-       KeysInterface& operator=(KeysInterface&& o) { KeysInterface_free(self); self = o.self; memset(&o, 0, sizeof(KeysInterface)); return *this; }
-       LDKKeysInterface* operator &() { return &self; }
-       LDKKeysInterface* operator ->() { return &self; }
-       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 ChainMonitor {
-private:
-       LDKChainMonitor 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; }
-};
-class FilesystemPersister {
-private:
-       LDKFilesystemPersister self;
-public:
-       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 ChannelManager {
-private:
-       LDKChannelManager 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; }
-};
-class ChainParameters {
-private:
-       LDKChainParameters 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; }
-};
-class BestBlock {
-private:
-       LDKBestBlock 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; }
-};
-class ChannelDetails {
-private:
-       LDKChannelDetails 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; }
-};
-class PaymentSendFailure {
-private:
-       LDKPaymentSendFailure 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; }
-};
-class ChannelManagerReadArgs {
-private:
-       LDKChannelManagerReadArgs 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; }
+class ChainMonitor {
+private:
+       LDKChainMonitor 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; }
 };
 class CVec_SpendableOutputDescriptorZ {
 private:
@@ -2032,20 +2062,20 @@ public:
        const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
        const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
 };
-class CResult_FundingCreatedDecodeErrorZ {
+class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
 private:
-       LDKCResult_FundingCreatedDecodeErrorZ self;
+       LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
 public:
-       CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
-       CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
-       CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
-       operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
-       ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
-       CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
-       LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_FundingCreatedDecodeErrorZ* 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 CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
 private:
@@ -2077,6 +2107,21 @@ public:
        const LDKCResult_HTLCUpdateDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() const { return &self; }
 };
+class C2Tuple_SignatureCVec_SignatureZZ {
+private:
+       LDKC2Tuple_SignatureCVec_SignatureZZ self;
+public:
+       C2Tuple_SignatureCVec_SignatureZZ(const C2Tuple_SignatureCVec_SignatureZZ&) = delete;
+       C2Tuple_SignatureCVec_SignatureZZ(C2Tuple_SignatureCVec_SignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); }
+       C2Tuple_SignatureCVec_SignatureZZ(LDKC2Tuple_SignatureCVec_SignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); }
+       operator LDKC2Tuple_SignatureCVec_SignatureZZ() && { LDKC2Tuple_SignatureCVec_SignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); return res; }
+       ~C2Tuple_SignatureCVec_SignatureZZ() { C2Tuple_SignatureCVec_SignatureZZ_free(self); }
+       C2Tuple_SignatureCVec_SignatureZZ& operator=(C2Tuple_SignatureCVec_SignatureZZ&& o) { C2Tuple_SignatureCVec_SignatureZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); return *this; }
+       LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() { return &self; }
+       LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() { return &self; }
+       const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; }
+       const LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() const { return &self; }
+};
 class CVec_C2Tuple_u32TxOutZZ {
 private:
        LDKCVec_C2Tuple_u32TxOutZZ self;
@@ -2092,21 +2137,6 @@ public:
        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:
        LDKCResult_ChannelInfoDecodeErrorZ self;
@@ -2122,35 +2152,35 @@ public:
        const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_SignatureCVec_SignatureZZ {
+class CResult_FundingCreatedDecodeErrorZ {
 private:
-       LDKC2Tuple_SignatureCVec_SignatureZZ self;
+       LDKCResult_FundingCreatedDecodeErrorZ self;
 public:
-       C2Tuple_SignatureCVec_SignatureZZ(const C2Tuple_SignatureCVec_SignatureZZ&) = delete;
-       C2Tuple_SignatureCVec_SignatureZZ(C2Tuple_SignatureCVec_SignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); }
-       C2Tuple_SignatureCVec_SignatureZZ(LDKC2Tuple_SignatureCVec_SignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); }
-       operator LDKC2Tuple_SignatureCVec_SignatureZZ() && { LDKC2Tuple_SignatureCVec_SignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); return res; }
-       ~C2Tuple_SignatureCVec_SignatureZZ() { C2Tuple_SignatureCVec_SignatureZZ_free(self); }
-       C2Tuple_SignatureCVec_SignatureZZ& operator=(C2Tuple_SignatureCVec_SignatureZZ&& o) { C2Tuple_SignatureCVec_SignatureZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); return *this; }
-       LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() { return &self; }
-       LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() { return &self; }
-       const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; }
-       const LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() const { return &self; }
+       CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
+       CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
+       CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
+       operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
+       ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
+       CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
+       LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+class CResult_ChannelAnnouncementDecodeErrorZ {
 private:
-       LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
+       LDKCResult_ChannelAnnouncementDecodeErrorZ self;
 public:
-       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; }
+       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_PositiveTimestampCreationErrorZ {
 private:
@@ -2182,21 +2212,6 @@ public:
        const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
        const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
 };
-class CResult_ChannelMonitorUpdateDecodeErrorZ {
-private:
-       LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
-public:
-       CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
-       CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
-       CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
-       operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
-       ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
-       CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
-       LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_InvoiceFeaturesDecodeErrorZ {
 private:
        LDKCResult_InvoiceFeaturesDecodeErrorZ self;
@@ -2212,6 +2227,21 @@ public:
        const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_ChannelMonitorUpdateDecodeErrorZ {
+private:
+       LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
+public:
+       CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
+       CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
+       CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
+       operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
+       ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
+       CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
+       LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
+};
 class COption_u64Z {
 private:
        LDKCOption_u64Z self;
@@ -2422,20 +2452,35 @@ public:
        const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_ExpiryTimeCreationErrorZ {
+class COption_C2Tuple_usizeTransactionZZ {
 private:
-       LDKCResult_ExpiryTimeCreationErrorZ self;
+       LDKCOption_C2Tuple_usizeTransactionZZ 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; }
+       COption_C2Tuple_usizeTransactionZZ(const COption_C2Tuple_usizeTransactionZZ&) = delete;
+       COption_C2Tuple_usizeTransactionZZ(COption_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_usizeTransactionZZ)); }
+       COption_C2Tuple_usizeTransactionZZ(LDKCOption_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); }
+       operator LDKCOption_C2Tuple_usizeTransactionZZ() && { LDKCOption_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); return res; }
+       ~COption_C2Tuple_usizeTransactionZZ() { COption_C2Tuple_usizeTransactionZZ_free(self); }
+       COption_C2Tuple_usizeTransactionZZ& operator=(COption_C2Tuple_usizeTransactionZZ&& o) { COption_C2Tuple_usizeTransactionZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_usizeTransactionZZ)); return *this; }
+       LDKCOption_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
+       LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
+       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_SignedRawInvoiceNoneZ {
 private:
@@ -2452,20 +2497,20 @@ public:
        const LDKCResult_SignedRawInvoiceNoneZ* operator &() const { return &self; }
        const LDKCResult_SignedRawInvoiceNoneZ* operator ->() const { return &self; }
 };
-class COption_C2Tuple_usizeTransactionZZ {
+class CResult_ExpiryTimeCreationErrorZ {
 private:
-       LDKCOption_C2Tuple_usizeTransactionZZ self;
+       LDKCResult_ExpiryTimeCreationErrorZ self;
 public:
-       COption_C2Tuple_usizeTransactionZZ(const COption_C2Tuple_usizeTransactionZZ&) = delete;
-       COption_C2Tuple_usizeTransactionZZ(COption_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_usizeTransactionZZ)); }
-       COption_C2Tuple_usizeTransactionZZ(LDKCOption_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); }
-       operator LDKCOption_C2Tuple_usizeTransactionZZ() && { LDKCOption_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); return res; }
-       ~COption_C2Tuple_usizeTransactionZZ() { COption_C2Tuple_usizeTransactionZZ_free(self); }
-       COption_C2Tuple_usizeTransactionZZ& operator=(COption_C2Tuple_usizeTransactionZZ&& o) { COption_C2Tuple_usizeTransactionZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_usizeTransactionZZ)); return *this; }
-       LDKCOption_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
-       LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
-       const LDKCOption_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
-       const LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
+       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_PingDecodeErrorZ {
 private:
@@ -2482,21 +2527,6 @@ 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;
@@ -2599,38 +2629,8 @@ public:
        CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
        LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
        LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_TxCreationKeysDecodeErrorZ {
-private:
-       LDKCResult_TxCreationKeysDecodeErrorZ self;
-public:
-       CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
-       CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
-       CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
-       operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
-       ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
-       CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
-       LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_TxCreationKeysDecodeErrorZ* 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; }
+       const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
 };
 class C2Tuple_usizeTransactionZ {
 private:
@@ -2647,6 +2647,21 @@ public:
        const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
        const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
 };
+class CResult_TxCreationKeysDecodeErrorZ {
+private:
+       LDKCResult_TxCreationKeysDecodeErrorZ self;
+public:
+       CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
+       CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
+       CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
+       operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
+       ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
+       CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
+       LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_ChannelFeaturesDecodeErrorZ {
 private:
        LDKCResult_ChannelFeaturesDecodeErrorZ self;
@@ -2662,20 +2677,35 @@ public:
        const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_ChannelFeaturesDecodeErrorZ* 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 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_UpdateFeeDecodeErrorZ {
 private:
@@ -2707,20 +2737,20 @@ public:
        const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_ChannelMonitorZ {
+class CResult_NodeAnnouncementDecodeErrorZ {
 private:
-       LDKCVec_ChannelMonitorZ self;
+       LDKCResult_NodeAnnouncementDecodeErrorZ 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_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_HTLCOutputInCommitmentDecodeErrorZ {
 private:
@@ -2797,21 +2827,6 @@ public:
        const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_NodeAnnouncementInfoDecodeErrorZ {
-private:
-       LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
-public:
-       CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
-       CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
-       CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
-       operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
-       ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
-       CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
-       LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_RecoverableSignatureNoneZ {
 private:
        LDKCResult_RecoverableSignatureNoneZ self;
@@ -2827,6 +2842,21 @@ public:
        const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
        const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
 };
+class CResult_NodeAnnouncementInfoDecodeErrorZ {
+private:
+       LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
+public:
+       CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
+       CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
+       CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
+       operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
+       ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
+       CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
+       LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_NetAddressu8Z {
 private:
        LDKCResult_NetAddressu8Z self;
@@ -2917,21 +2947,6 @@ public:
        const LDKCResult_RouteHintCreationErrorZ* operator &() const { return &self; }
        const LDKCResult_RouteHintCreationErrorZ* operator ->() const { return &self; }
 };
-class CResult_NodeInfoDecodeErrorZ {
-private:
-       LDKCResult_NodeInfoDecodeErrorZ self;
-public:
-       CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
-       CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
-       CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
-       operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
-       ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
-       CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
-       LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
-};
 class CVec_C2Tuple_BlockHashChannelMonitorZZ {
 private:
        LDKCVec_C2Tuple_BlockHashChannelMonitorZZ self;
@@ -2947,20 +2962,35 @@ public:
        const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() const { return &self; }
        const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() const { return &self; }
 };
-class CVec_u8Z {
+class CResult_NonePaymentSendFailureZ {
 private:
-       LDKCVec_u8Z self;
+       LDKCResult_NonePaymentSendFailureZ self;
 public:
-       CVec_u8Z(const CVec_u8Z&) = delete;
-       CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
-       CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
-       operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
-       ~CVec_u8Z() { CVec_u8Z_free(self); }
-       CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
-       LDKCVec_u8Z* operator &() { return &self; }
-       LDKCVec_u8Z* operator ->() { return &self; }
-       const LDKCVec_u8Z* operator &() const { return &self; }
-       const LDKCVec_u8Z* operator ->() const { return &self; }
+       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_RouteLightningErrorZ {
+private:
+       LDKCResult_RouteLightningErrorZ self;
+public:
+       CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
+       CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
+       CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
+       operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
+       ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
+       CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
+       LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
+       LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
+       const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
+       const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
 };
 class CResult_ChannelPublicKeysDecodeErrorZ {
 private:
@@ -2977,35 +3007,35 @@ public:
        const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_RouteLightningErrorZ {
+class CVec_u8Z {
 private:
-       LDKCResult_RouteLightningErrorZ self;
+       LDKCVec_u8Z self;
 public:
-       CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
-       CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
-       CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
-       operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
-       ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
-       CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
-       LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
-       LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
-       const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
-       const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
+       CVec_u8Z(const CVec_u8Z&) = delete;
+       CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
+       CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
+       operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
+       ~CVec_u8Z() { CVec_u8Z_free(self); }
+       CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
+       LDKCVec_u8Z* operator &() { return &self; }
+       LDKCVec_u8Z* operator ->() { return &self; }
+       const LDKCVec_u8Z* operator &() const { return &self; }
+       const LDKCVec_u8Z* operator ->() const { return &self; }
 };
-class CResult_NonePaymentSendFailureZ {
+class CResult_NodeInfoDecodeErrorZ {
 private:
-       LDKCResult_NonePaymentSendFailureZ self;
+       LDKCResult_NodeInfoDecodeErrorZ 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; }
+       CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
+       CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
+       CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
+       operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
+       ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
+       CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
+       LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_ClosingSignedDecodeErrorZ {
 private:
@@ -3232,21 +3262,6 @@ 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;
@@ -3277,21 +3292,6 @@ public:
        const LDKCResult_NoneMonitorUpdateErrorZ* operator &() const { return &self; }
        const LDKCResult_NoneMonitorUpdateErrorZ* operator ->() const { return &self; }
 };
-class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
-private:
-       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
-public:
-       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
-       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
-       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
-       operator LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
-       ~CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
-       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ& operator=(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return *this; }
-       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
-       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
-       const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
-       const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
-};
 class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
 private:
        LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ self;
@@ -3307,20 +3307,35 @@ public:
        const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() const { return &self; }
        const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() const { return &self; }
 };
-class CResult_AcceptChannelDecodeErrorZ {
+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_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
 private:
-       LDKCResult_AcceptChannelDecodeErrorZ self;
+       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
 public:
-       CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
-       CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
-       CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
-       operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
-       ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
-       CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
-       LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
+       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
+       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
+       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
+       operator LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
+       ~CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
+       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ& operator=(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return *this; }
+       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
+       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
+       const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
+       const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
 };
 class CResult_CVec_CVec_u8ZZNoneZ {
 private:
@@ -3352,6 +3367,21 @@ public:
        const LDKC2Tuple_PaymentHashPaymentSecretZ* operator &() const { return &self; }
        const LDKC2Tuple_PaymentHashPaymentSecretZ* operator ->() const { return &self; }
 };
+class CResult_AcceptChannelDecodeErrorZ {
+private:
+       LDKCResult_AcceptChannelDecodeErrorZ self;
+public:
+       CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
+       CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
+       CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
+       operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
+       ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
+       CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
+       LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_BlockHashChannelManagerZ {
 private:
        LDKC2Tuple_BlockHashChannelManagerZ self;
@@ -3382,20 +3412,20 @@ public:
        const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+class CResult_PongDecodeErrorZ {
 private:
-       LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ self;
+       LDKCResult_PongDecodeErrorZ 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; }
+       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_SignatureZ {
 private:
@@ -3667,21 +3697,6 @@ public:
        const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
-private:
-       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
-public:
-       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
-       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
-       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
-       operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
-       ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
-       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
-       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_NoneAPIErrorZ {
 private:
        LDKCResult_NoneAPIErrorZ self;
@@ -3697,6 +3712,21 @@ public:
        const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
        const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
 };
+class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
+private:
+       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
+public:
+       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
+       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
+       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
+       operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
+       ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
+       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
+       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_NetAddressZ {
 private:
        LDKCVec_NetAddressZ self;
@@ -3892,21 +3922,6 @@ public:
        const LDKCResult_NoneSemanticErrorZ* operator &() const { return &self; }
        const LDKCResult_NoneSemanticErrorZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_u32ScriptZZ {
-private:
-       LDKCVec_C2Tuple_u32ScriptZZ self;
-public:
-       CVec_C2Tuple_u32ScriptZZ(const CVec_C2Tuple_u32ScriptZZ&) = delete;
-       CVec_C2Tuple_u32ScriptZZ(CVec_C2Tuple_u32ScriptZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); }
-       CVec_C2Tuple_u32ScriptZZ(LDKCVec_C2Tuple_u32ScriptZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); }
-       operator LDKCVec_C2Tuple_u32ScriptZZ() && { LDKCVec_C2Tuple_u32ScriptZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); return res; }
-       ~CVec_C2Tuple_u32ScriptZZ() { CVec_C2Tuple_u32ScriptZZ_free(self); }
-       CVec_C2Tuple_u32ScriptZZ& operator=(CVec_C2Tuple_u32ScriptZZ&& o) { CVec_C2Tuple_u32ScriptZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); return *this; }
-       LDKCVec_C2Tuple_u32ScriptZZ* operator &() { return &self; }
-       LDKCVec_C2Tuple_u32ScriptZZ* operator ->() { return &self; }
-       const LDKCVec_C2Tuple_u32ScriptZZ* operator &() const { return &self; }
-       const LDKCVec_C2Tuple_u32ScriptZZ* operator ->() const { return &self; }
-};
 class CVec_MonitorEventZ {
 private:
        LDKCVec_MonitorEventZ self;
@@ -3922,6 +3937,21 @@ public:
        const LDKCVec_MonitorEventZ* operator &() const { return &self; }
        const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
 };
+class CVec_C2Tuple_u32ScriptZZ {
+private:
+       LDKCVec_C2Tuple_u32ScriptZZ self;
+public:
+       CVec_C2Tuple_u32ScriptZZ(const CVec_C2Tuple_u32ScriptZZ&) = delete;
+       CVec_C2Tuple_u32ScriptZZ(CVec_C2Tuple_u32ScriptZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); }
+       CVec_C2Tuple_u32ScriptZZ(LDKCVec_C2Tuple_u32ScriptZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); }
+       operator LDKCVec_C2Tuple_u32ScriptZZ() && { LDKCVec_C2Tuple_u32ScriptZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); return res; }
+       ~CVec_C2Tuple_u32ScriptZZ() { CVec_C2Tuple_u32ScriptZZ_free(self); }
+       CVec_C2Tuple_u32ScriptZZ& operator=(CVec_C2Tuple_u32ScriptZZ&& o) { CVec_C2Tuple_u32ScriptZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); return *this; }
+       LDKCVec_C2Tuple_u32ScriptZZ* operator &() { return &self; }
+       LDKCVec_C2Tuple_u32ScriptZZ* operator ->() { return &self; }
+       const LDKCVec_C2Tuple_u32ScriptZZ* operator &() const { return &self; }
+       const LDKCVec_C2Tuple_u32ScriptZZ* operator ->() const { return &self; }
+};
 class CResult_NoneChannelMonitorUpdateErrZ {
 private:
        LDKCResult_NoneChannelMonitorUpdateErrZ self;
@@ -4087,21 +4117,6 @@ public:
        const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
-private:
-       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
-public:
-       CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
-       CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
-       CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
-       operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
-       ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
-       CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
-       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_InMemorySignerDecodeErrorZ {
 private:
        LDKCResult_InMemorySignerDecodeErrorZ self;
@@ -4117,6 +4132,21 @@ public:
        const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_InMemorySignerDecodeErrorZ* 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 C2Tuple_u32ScriptZ {
 private:
        LDKC2Tuple_u32ScriptZ self;
@@ -4147,35 +4177,35 @@ public:
        const LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_PaymentSecretAPIErrorZ {
+class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
 private:
-       LDKCResult_PaymentSecretAPIErrorZ self;
+       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ 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; }
+       CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
+       CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
+       CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
+       operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
+       ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
+       CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
+       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+class CResult_RouteDecodeErrorZ {
 private:
-       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
+       LDKCResult_RouteDecodeErrorZ self;
 public:
-       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&) = delete;
-       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
-       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
-       operator LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return res; }
-       ~CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); }
-       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return *this; }
-       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
+       CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
+       CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
+       CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
+       operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
+       ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
+       CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
+       LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_BuiltCommitmentTransactionDecodeErrorZ {
 private:
@@ -4192,20 +4222,35 @@ public:
        const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_RouteDecodeErrorZ {
+class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
 private:
-       LDKCResult_RouteDecodeErrorZ self;
+       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
 public:
-       CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
-       CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
-       CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
-       operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
-       ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
-       CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
-       LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
+       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&) = delete;
+       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
+       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
+       operator LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return res; }
+       ~CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); }
+       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return *this; }
+       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* 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:
@@ -4237,19 +4282,4 @@ 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; }
-};
 }