_ Git - ldk-c-bindings/blob - lightning-c-bindings/include/lightningpp.hpp

   1 #include <string.h>
   2 namespace LDK {
   3 // Forward declarations
   4 class Str;
   5 class CounterpartyCommitmentSecrets;
   6 class TxCreationKeys;
   7 class ChannelPublicKeys;
   8 class HTLCOutputInCommitment;
   9 class ChannelTransactionParameters;
  10 class CounterpartyChannelTransactionParameters;
  11 class DirectedChannelTransactionParameters;
  12 class HolderCommitmentTransaction;
  13 class BuiltCommitmentTransaction;
  14 class ClosingTransaction;
  15 class TrustedClosingTransaction;
  16 class CommitmentTransaction;
  17 class TrustedCommitmentTransaction;
  18 class ShutdownScript;
  19 class InvalidShutdownScript;
  20 class BackgroundProcessor;
  21 class ChannelManagerPersister;
  22 class RouteHop;
  23 class Route;
  24 class RouteParameters;
  25 class PaymentParameters;
  26 class RouteHint;
  27 class RouteHintHop;
  28 class BroadcasterInterface;
  29 class ConfirmationTarget;
  30 class FeeEstimator;
  31 class BestBlock;
  32 class AccessError;
  33 class Access;
  34 class Listen;
  35 class Confirm;
  36 class ChannelMonitorUpdateErr;
  37 class Watch;
  38 class Filter;
  39 class WatchedOutput;
  40 class PaymentPurpose;
  41 class ClosureReason;
  42 class Event;
  43 class MessageSendEvent;
  44 class MessageSendEventsProvider;
  45 class EventsProvider;
  46 class EventHandler;
  47 class Score;
  48 class LockableScore;
  49 class MultiThreadedLockableScore;
  50 class FixedPenaltyScorer;
  51 class Scorer;
  52 class ScoringParameters;
  53 class ProbabilisticScorer;
  54 class ProbabilisticScoringParameters;
  55 class InitFeatures;
  56 class NodeFeatures;
  57 class ChannelFeatures;
  58 class InvoiceFeatures;
  59 class ChannelTypeFeatures;
  60 class DelayedPaymentOutputDescriptor;
  61 class StaticPaymentOutputDescriptor;
  62 class SpendableOutputDescriptor;
  63 class BaseSign;
  64 class Sign;
  65 class Recipient;
  66 class KeysInterface;
  67 class InMemorySigner;
  68 class KeysManager;
  69 class PhantomKeysManager;
  70 class FilesystemPersister;
  71 class ChannelManager;
  72 class ChainParameters;
  73 class CounterpartyForwardingInfo;
  74 class ChannelCounterparty;
  75 class ChannelDetails;
  76 class PaymentSendFailure;
  77 class PhantomRouteHints;
  78 class ChannelManagerReadArgs;
  79 class ChannelHandshakeConfig;
  80 class ChannelHandshakeLimits;
  81 class ChannelConfig;
  82 class UserConfig;
  83 class APIError;
  84 class OutPoint;
  85 class CustomMessageReader;
  86 class Type;
  87 class InvoicePayer;
  88 class Payer;
  89 class Router;
  90 class RetryAttempts;
  91 class PaymentError;
  92 class Invoice;
  93 class SignedRawInvoice;
  94 class RawInvoice;
  95 class RawDataPart;
  96 class PositiveTimestamp;
  97 class SiPrefix;
  98 class Currency;
  99 class Sha256;
 100 class Description;
 101 class PayeePubKey;
 102 class ExpiryTime;
 103 class MinFinalCltvExpiry;
 104 class Fallback;
 105 class InvoiceSignature;
 106 class PrivateRoute;
 107 class CreationError;
 108 class SemanticError;
 109 class SignOrCreationError;
 110 class ChannelMonitorUpdate;
 111 class MonitorEvent;
 112 class HTLCUpdate;
 113 class Balance;
 114 class ChannelMonitor;
 115 class CustomMessageHandler;
 116 class IgnoringMessageHandler;
 117 class ErroringMessageHandler;
 118 class MessageHandler;
 119 class SocketDescriptor;
 120 class PeerHandleError;
 121 class PeerManager;
 122 class NodeId;
 123 class NetworkGraph;
 124 class ReadOnlyNetworkGraph;
 125 class NetworkUpdate;
 126 class NetGraphMsgHandler;
 127 class ChannelUpdateInfo;
 128 class ChannelInfo;
 129 class DirectedChannelInfo;
 130 class EffectiveCapacity;
 131 class RoutingFees;
 132 class NodeAnnouncementInfo;
 133 class NodeInfo;
 134 class DecodeError;
 135 class Init;
 136 class ErrorMessage;
 137 class WarningMessage;
 138 class Ping;
 139 class Pong;
 140 class OpenChannel;
 141 class AcceptChannel;
 142 class FundingCreated;
 143 class FundingSigned;
 144 class FundingLocked;
 145 class Shutdown;
 146 class ClosingSignedFeeRange;
 147 class ClosingSigned;
 148 class UpdateAddHTLC;
 149 class UpdateFulfillHTLC;
 150 class UpdateFailHTLC;
 151 class UpdateFailMalformedHTLC;
 152 class CommitmentSigned;
 153 class RevokeAndACK;
 154 class UpdateFee;
 155 class DataLossProtect;
 156 class ChannelReestablish;
 157 class AnnouncementSignatures;
 158 class NetAddress;
 159 class UnsignedNodeAnnouncement;
 160 class NodeAnnouncement;
 161 class UnsignedChannelAnnouncement;
 162 class ChannelAnnouncement;
 163 class UnsignedChannelUpdate;
 164 class ChannelUpdate;
 165 class QueryChannelRange;
 166 class ReplyChannelRange;
 167 class QueryShortChannelIds;
 168 class ReplyShortChannelIdsEnd;
 169 class GossipTimestampFilter;
 170 class ErrorAction;
 171 class LightningError;
 172 class CommitmentUpdate;
 173 class ChannelMessageHandler;
 174 class RoutingMessageHandler;
 175 class DefaultRouter;
 176 class Level;
 177 class Record;
 178 class Logger;
 179 class MonitorUpdateId;
 180 class Persist;
 181 class LockedChannelMonitor;
 182 class ChainMonitor;
 183 class CVec_SpendableOutputDescriptorZ;
 184 class CResult_LockedChannelMonitorNoneZ;
 185 class CResult_PhantomRouteHintsDecodeErrorZ;
 186 class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ;
 187 class CResult_ScoringParametersDecodeErrorZ;
 188 class CResult_HTLCUpdateDecodeErrorZ;
 189 class C2Tuple_SignatureCVec_SignatureZZ;
 190 class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
 191 class CVec_C2Tuple_u32TxOutZZ;
 192 class CResult_ChannelInfoDecodeErrorZ;
 193 class CResult_FundingCreatedDecodeErrorZ;
 194 class CResult_ChannelAnnouncementDecodeErrorZ;
 195 class CVec_OutPointZ;
 196 class CResult_PositiveTimestampCreationErrorZ;
 197 class CResult_CVec_u8ZPeerHandleErrorZ;
 198 class CResult_InvoiceFeaturesDecodeErrorZ;
 199 class COption_NetworkUpdateZ;
 200 class COption_u64Z;
 201 class CResult_TxOutAccessErrorZ;
 202 class CResult_TrustedClosingTransactionNoneZ;
 203 class CResult_PaymentPreimageAPIErrorZ;
 204 class CResult_ChannelMonitorUpdateDecodeErrorZ;
 205 class CResult_RouteHintDecodeErrorZ;
 206 class C2Tuple_PublicKeyTypeZ;
 207 class CResult_NetAddressDecodeErrorZ;
 208 class CResult_ChannelReestablishDecodeErrorZ;
 209 class CResult_CommitmentSignedDecodeErrorZ;
 210 class CVec_UpdateAddHTLCZ;
 211 class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
 212 class COption_u32Z;
 213 class CResult_InitFeaturesDecodeErrorZ;
 214 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
 215 class CResult_PaymentIdPaymentSendFailureZ;
 216 class CResult_ReplyChannelRangeDecodeErrorZ;
 217 class CResult_CommitmentTransactionDecodeErrorZ;
 218 class COption_C2Tuple_usizeTransactionZZ;
 219 class CResult_TransactionNoneZ;
 220 class CResult_SignedRawInvoiceNoneZ;
 221 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
 222 class CResult_PingDecodeErrorZ;
 223 class CResult_GossipTimestampFilterDecodeErrorZ;
 224 class CResult_InvoiceSignOrCreationErrorZ;
 225 class CVec_TransactionOutputsZ;
 226 class CResult_ErrorMessageDecodeErrorZ;
 227 class CResult_OpenChannelDecodeErrorZ;
 228 class CVec_CVec_u8ZZ;
 229 class COption_FilterZ;
 230 class CResult_ProbabilisticScorerDecodeErrorZ;
 231 class CResult_SecretKeyErrorZ;
 232 class CResult_ShutdownScriptDecodeErrorZ;
 233 class CResult_InvoiceNoneZ;
 234 class CResult_TxCreationKeysDecodeErrorZ;
 235 class C2Tuple_usizeTransactionZ;
 236 class CResult_ChannelFeaturesDecodeErrorZ;
 237 class CVec_ChannelMonitorZ;
 238 class CVec_TransactionZ;
 239 class CResult_UpdateFeeDecodeErrorZ;
 240 class CResult_RouteHopDecodeErrorZ;
 241 class CResult_NodeAnnouncementDecodeErrorZ;
 242 class CResult_QueryChannelRangeDecodeErrorZ;
 243 class CVec_BalanceZ;
 244 class CResult_HTLCOutputInCommitmentDecodeErrorZ;
 245 class CResult_boolLightningErrorZ;
 246 class CResult_TxCreationKeysErrorZ;
 247 class C2Tuple_BlockHashChannelMonitorZ;
 248 class CResult_NodeIdDecodeErrorZ;
 249 class CResult_ShutdownScriptInvalidShutdownScriptZ;
 250 class CResult_RecoverableSignatureNoneZ;
 251 class CResult_COption_NetworkUpdateZDecodeErrorZ;
 252 class CResult_NodeAnnouncementInfoDecodeErrorZ;
 253 class C3Tuple_RawInvoice_u832InvoiceSignatureZ;
 254 class CVec_UpdateFailMalformedHTLCZ;
 255 class CResult_FundingSignedDecodeErrorZ;
 256 class CResult_NetworkGraphDecodeErrorZ;
 257 class CVec_RouteHopZ;
 258 class CVec_C2Tuple_BlockHashChannelMonitorZZ;
 259 class CResult_NonePaymentSendFailureZ;
 260 class CResult_RouteLightningErrorZ;
 261 class CResult_ChannelPublicKeysDecodeErrorZ;
 262 class CVec_u8Z;
 263 class CResult_NodeInfoDecodeErrorZ;
 264 class CResult_ClosingSignedDecodeErrorZ;
 265 class CResult_HolderCommitmentTransactionDecodeErrorZ;
 266 class CVec_CResult_NoneAPIErrorZZ;
 267 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
 268 class CResult_ChannelCounterpartyDecodeErrorZ;
 269 class CResult_WarningMessageDecodeErrorZ;
 270 class CResult_SignatureNoneZ;
 271 class CVec_RouteHintHopZ;
 272 class CResult_SecretKeyNoneZ;
 273 class CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ;
 274 class C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ;
 275 class CResult_PaymentParametersDecodeErrorZ;
 276 class CResult_InitDecodeErrorZ;
 277 class CResult_OutPointDecodeErrorZ;
 278 class CVec_ChannelDetailsZ;
 279 class CResult_SignDecodeErrorZ;
 280 class CVec_MessageSendEventZ;
 281 class C2Tuple_OutPointScriptZ;
 282 class CResult_RouteHintHopDecodeErrorZ;
 283 class CResult_C2Tuple_SignatureSignatureZNoneZ;
 284 class CVec_NodeAnnouncementZ;
 285 class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
 286 class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
 287 class CVec_TxidZ;
 288 class COption_AccessZ;
 289 class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ;
 290 class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ;
 291 class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
 292 class CResult_CVec_CVec_u8ZZNoneZ;
 293 class C2Tuple_SignatureSignatureZ;
 294 class C2Tuple_PaymentHashPaymentSecretZ;
 295 class C2Tuple_BlockHashChannelManagerZ;
 296 class CResult_ChannelTransactionParametersDecodeErrorZ;
 297 class CResult_AcceptChannelDecodeErrorZ;
 298 class CVec_SignatureZ;
 299 class CVec_u64Z;
 300 class CResult_ScorerDecodeErrorZ;
 301 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
 302 class C2Tuple_PaymentHashPaymentIdZ;
 303 class CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ;
 304 class CResult_NoneErrorZ;
 305 class CResult_StringErrorZ;
 306 class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
 307 class CResult_PongDecodeErrorZ;
 308 class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ;
 309 class COption_EventZ;
 310 class CResult_ChannelTypeFeaturesDecodeErrorZ;
 311 class CVec_RouteHintZ;
 312 class COption_u16Z;
 313 class CVec_CVec_RouteHopZZ;
 314 class CResult_TrustedCommitmentTransactionNoneZ;
 315 class CResult_FixedPenaltyScorerDecodeErrorZ;
 316 class CResult_NoneLightningErrorZ;
 317 class CResult_NonePeerHandleErrorZ;
 318 class CResult_COption_EventZDecodeErrorZ;
 319 class CResult_CVec_SignatureZNoneZ;
 320 class COption_CVec_NetAddressZZ;
 321 class CResult__u832APIErrorZ;
 322 class CResult_PaymentIdPaymentErrorZ;
 323 class CResult_DescriptionCreationErrorZ;
 324 class CResult_COption_MonitorEventZDecodeErrorZ;
 325 class CResult_PayeePubKeyErrorZ;
 326 class CVec_C2Tuple_PublicKeyTypeZZ;
 327 class CResult_RoutingFeesDecodeErrorZ;
 328 class CResult_QueryShortChannelIdsDecodeErrorZ;
 329 class CResult_InvoiceSemanticErrorZ;
 330 class CResult_UpdateAddHTLCDecodeErrorZ;
 331 class CVec_PhantomRouteHintsZ;
 332 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
 333 class CResult_NoneAPIErrorZ;
 334 class CVec_NetAddressZ;
 335 class CResult_ChannelDetailsDecodeErrorZ;
 336 class CVec_C2Tuple_usizeTransactionZZ;
 337 class CVec_PublicKeyZ;
 338 class COption_MonitorEventZ;
 339 class COption_TypeZ;
 340 class CResult_COption_TypeZDecodeErrorZ;
 341 class C2Tuple_u32TxOutZ;
 342 class CResult_UpdateFailHTLCDecodeErrorZ;
 343 class CResult_PaymentSecretNoneZ;
 344 class CResult_ChannelConfigDecodeErrorZ;
 345 class CVec_PrivateRouteZ;
 346 class CResult_SpendableOutputDescriptorDecodeErrorZ;
 347 class CResult_RevokeAndACKDecodeErrorZ;
 348 class CResult_UnsignedChannelUpdateDecodeErrorZ;
 349 class CResult_ShutdownDecodeErrorZ;
 350 class CVec_EventZ;
 351 class CResult_NoneSemanticErrorZ;
 352 class CVec_MonitorEventZ;
 353 class CVec_PaymentPreimageZ;
 354 class CVec_C2Tuple_u32ScriptZZ;
 355 class CResult_NoneChannelMonitorUpdateErrZ;
 356 class CResult_COption_ClosureReasonZDecodeErrorZ;
 357 class CResult_SiPrefixNoneZ;
 358 class CResult_PublicKeyErrorZ;
 359 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
 360 class CResult_NoneNoneZ;
 361 class CResult_RouteParametersDecodeErrorZ;
 362 class COption_ClosureReasonZ;
 363 class CVec_APIErrorZ;
 364 class CResult_PrivateRouteCreationErrorZ;
 365 class CResult_boolPeerHandleErrorZ;
 366 class CResult_ChannelUpdateDecodeErrorZ;
 367 class CVec_UpdateFulfillHTLCZ;
 368 class CResult_AnnouncementSignaturesDecodeErrorZ;
 369 class CResult_UpdateFulfillHTLCDecodeErrorZ;
 370 class CResult_NodeFeaturesDecodeErrorZ;
 371 class CVec_u5Z;
 372 class CResult_InMemorySignerDecodeErrorZ;
 373 class CResult_PaymentSecretAPIErrorZ;
 374 class CResult_CounterpartyForwardingInfoDecodeErrorZ;
 375 class C2Tuple_u32ScriptZ;
 376 class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
 377 class CResult_RouteDecodeErrorZ;
 378 class CResult_BuiltCommitmentTransactionDecodeErrorZ;
 379 class COption_NoneZ;
 380 class CVec_TxOutZ;
 381 class CResult_ProbabilisticScoringParametersDecodeErrorZ;
 382 class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
 383 class CResult_ChannelUpdateInfoDecodeErrorZ;
 384 class CVec_UpdateFailHTLCZ;
 385 class CResult_FundingLockedDecodeErrorZ;
 386
 387 class Str {
 388 private:
 389         LDKStr self;
 390 public:
 391         Str(const Str&) = delete;
 392         Str(Str&& o) : self(o.self) { memset(&o, 0, sizeof(Str)); }
 393         Str(LDKStr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStr)); }
 394         operator LDKStr() && { LDKStr res = self; memset(&self, 0, sizeof(LDKStr)); return res; }
 395         ~Str() { Str_free(self); }
 396         Str& operator=(Str&& o) { Str_free(self); self = o.self; memset(&o, 0, sizeof(Str)); return *this; }
 397         LDKStr* operator &() { return &self; }
 398         LDKStr* operator ->() { return &self; }
 399         const LDKStr* operator &() const { return &self; }
 400         const LDKStr* operator ->() const { return &self; }
 401 };
 402 class CounterpartyCommitmentSecrets {
 403 private:
 404         LDKCounterpartyCommitmentSecrets self;
 405 public:
 406         CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
 407         CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
 408         CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
 409         operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
 410         ~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
 411         CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
 412         LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
 413         LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
 414         const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
 415         const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
 416 };
 417 class TxCreationKeys {
 418 private:
 419         LDKTxCreationKeys self;
 420 public:
 421         TxCreationKeys(const TxCreationKeys&) = delete;
 422         TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
 423         TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
 424         operator LDKTxCreationKeys() && { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
 425         ~TxCreationKeys() { TxCreationKeys_free(self); }
 426         TxCreationKeys& operator=(TxCreationKeys&& o) { TxCreationKeys_free(self); self = o.self; memset(&o, 0, sizeof(TxCreationKeys)); return *this; }
 427         LDKTxCreationKeys* operator &() { return &self; }
 428         LDKTxCreationKeys* operator ->() { return &self; }
 429         const LDKTxCreationKeys* operator &() const { return &self; }
 430         const LDKTxCreationKeys* operator ->() const { return &self; }
 431 };
 432 class ChannelPublicKeys {
 433 private:
 434         LDKChannelPublicKeys self;
 435 public:
 436         ChannelPublicKeys(const ChannelPublicKeys&) = delete;
 437         ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
 438         ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
 439         operator LDKChannelPublicKeys() && { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
 440         ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }
 441         ChannelPublicKeys& operator=(ChannelPublicKeys&& o) { ChannelPublicKeys_free(self); self = o.self; memset(&o, 0, sizeof(ChannelPublicKeys)); return *this; }
 442         LDKChannelPublicKeys* operator &() { return &self; }
 443         LDKChannelPublicKeys* operator ->() { return &self; }
 444         const LDKChannelPublicKeys* operator &() const { return &self; }
 445         const LDKChannelPublicKeys* operator ->() const { return &self; }
 446 };
 447 class HTLCOutputInCommitment {
 448 private:
 449         LDKHTLCOutputInCommitment self;
 450 public:
 451         HTLCOutputInCommitment(const HTLCOutputInCommitment&) = delete;
 452         HTLCOutputInCommitment(HTLCOutputInCommitment&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCOutputInCommitment)); }
 453         HTLCOutputInCommitment(LDKHTLCOutputInCommitment&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCOutputInCommitment)); }
 454         operator LDKHTLCOutputInCommitment() && { LDKHTLCOutputInCommitment res = self; memset(&self, 0, sizeof(LDKHTLCOutputInCommitment)); return res; }
 455         ~HTLCOutputInCommitment() { HTLCOutputInCommitment_free(self); }
 456         HTLCOutputInCommitment& operator=(HTLCOutputInCommitment&& o) { HTLCOutputInCommitment_free(self); self = o.self; memset(&o, 0, sizeof(HTLCOutputInCommitment)); return *this; }
 457         LDKHTLCOutputInCommitment* operator &() { return &self; }
 458         LDKHTLCOutputInCommitment* operator ->() { return &self; }
 459         const LDKHTLCOutputInCommitment* operator &() const { return &self; }
 460         const LDKHTLCOutputInCommitment* operator ->() const { return &self; }
 461 };
 462 class ChannelTransactionParameters {
 463 private:
 464         LDKChannelTransactionParameters self;
 465 public:
 466         ChannelTransactionParameters(const ChannelTransactionParameters&) = delete;
 467         ChannelTransactionParameters(ChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTransactionParameters)); }
 468         ChannelTransactionParameters(LDKChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTransactionParameters)); }
 469         operator LDKChannelTransactionParameters() && { LDKChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKChannelTransactionParameters)); return res; }
 470         ~ChannelTransactionParameters() { ChannelTransactionParameters_free(self); }
 471         ChannelTransactionParameters& operator=(ChannelTransactionParameters&& o) { ChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTransactionParameters)); return *this; }
 472         LDKChannelTransactionParameters* operator &() { return &self; }
 473         LDKChannelTransactionParameters* operator ->() { return &self; }
 474         const LDKChannelTransactionParameters* operator &() const { return &self; }
 475         const LDKChannelTransactionParameters* operator ->() const { return &self; }
 476 };
 477 class CounterpartyChannelTransactionParameters {
 478 private:
 479         LDKCounterpartyChannelTransactionParameters self;
 480 public:
 481         CounterpartyChannelTransactionParameters(const CounterpartyChannelTransactionParameters&) = delete;
 482         CounterpartyChannelTransactionParameters(CounterpartyChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); }
 483         CounterpartyChannelTransactionParameters(LDKCounterpartyChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); }
 484         operator LDKCounterpartyChannelTransactionParameters() && { LDKCounterpartyChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); return res; }
 485         ~CounterpartyChannelTransactionParameters() { CounterpartyChannelTransactionParameters_free(self); }
 486         CounterpartyChannelTransactionParameters& operator=(CounterpartyChannelTransactionParameters&& o) { CounterpartyChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); return *this; }
 487         LDKCounterpartyChannelTransactionParameters* operator &() { return &self; }
 488         LDKCounterpartyChannelTransactionParameters* operator ->() { return &self; }
 489         const LDKCounterpartyChannelTransactionParameters* operator &() const { return &self; }
 490         const LDKCounterpartyChannelTransactionParameters* operator ->() const { return &self; }
 491 };
 492 class DirectedChannelTransactionParameters {
 493 private:
 494         LDKDirectedChannelTransactionParameters self;
 495 public:
 496         DirectedChannelTransactionParameters(const DirectedChannelTransactionParameters&) = delete;
 497         DirectedChannelTransactionParameters(DirectedChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); }
 498         DirectedChannelTransactionParameters(LDKDirectedChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelTransactionParameters)); }
 499         operator LDKDirectedChannelTransactionParameters() && { LDKDirectedChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKDirectedChannelTransactionParameters)); return res; }
 500         ~DirectedChannelTransactionParameters() { DirectedChannelTransactionParameters_free(self); }
 501         DirectedChannelTransactionParameters& operator=(DirectedChannelTransactionParameters&& o) { DirectedChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); return *this; }
 502         LDKDirectedChannelTransactionParameters* operator &() { return &self; }
 503         LDKDirectedChannelTransactionParameters* operator ->() { return &self; }
 504         const LDKDirectedChannelTransactionParameters* operator &() const { return &self; }
 505         const LDKDirectedChannelTransactionParameters* operator ->() const { return &self; }
 506 };
 507 class HolderCommitmentTransaction {
 508 private:
 509         LDKHolderCommitmentTransaction self;
 510 public:
 511         HolderCommitmentTransaction(const HolderCommitmentTransaction&) = delete;
 512         HolderCommitmentTransaction(HolderCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(HolderCommitmentTransaction)); }
 513         HolderCommitmentTransaction(LDKHolderCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHolderCommitmentTransaction)); }
 514         operator LDKHolderCommitmentTransaction() && { LDKHolderCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKHolderCommitmentTransaction)); return res; }
 515         ~HolderCommitmentTransaction() { HolderCommitmentTransaction_free(self); }
 516         HolderCommitmentTransaction& operator=(HolderCommitmentTransaction&& o) { HolderCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(HolderCommitmentTransaction)); return *this; }
 517         LDKHolderCommitmentTransaction* operator &() { return &self; }
 518         LDKHolderCommitmentTransaction* operator ->() { return &self; }
 519         const LDKHolderCommitmentTransaction* operator &() const { return &self; }
 520         const LDKHolderCommitmentTransaction* operator ->() const { return &self; }
 521 };
 522 class BuiltCommitmentTransaction {
 523 private:
 524         LDKBuiltCommitmentTransaction self;
 525 public:
 526         BuiltCommitmentTransaction(const BuiltCommitmentTransaction&) = delete;
 527         BuiltCommitmentTransaction(BuiltCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(BuiltCommitmentTransaction)); }
 528         BuiltCommitmentTransaction(LDKBuiltCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBuiltCommitmentTransaction)); }
 529         operator LDKBuiltCommitmentTransaction() && { LDKBuiltCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKBuiltCommitmentTransaction)); return res; }
 530         ~BuiltCommitmentTransaction() { BuiltCommitmentTransaction_free(self); }
 531         BuiltCommitmentTransaction& operator=(BuiltCommitmentTransaction&& o) { BuiltCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(BuiltCommitmentTransaction)); return *this; }
 532         LDKBuiltCommitmentTransaction* operator &() { return &self; }
 533         LDKBuiltCommitmentTransaction* operator ->() { return &self; }
 534         const LDKBuiltCommitmentTransaction* operator &() const { return &self; }
 535         const LDKBuiltCommitmentTransaction* operator ->() const { return &self; }
 536 };
 537 class ClosingTransaction {
 538 private:
 539         LDKClosingTransaction self;
 540 public:
 541         ClosingTransaction(const ClosingTransaction&) = delete;
 542         ClosingTransaction(ClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingTransaction)); }
 543         ClosingTransaction(LDKClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingTransaction)); }
 544         operator LDKClosingTransaction() && { LDKClosingTransaction res = self; memset(&self, 0, sizeof(LDKClosingTransaction)); return res; }
 545         ~ClosingTransaction() { ClosingTransaction_free(self); }
 546         ClosingTransaction& operator=(ClosingTransaction&& o) { ClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(ClosingTransaction)); return *this; }
 547         LDKClosingTransaction* operator &() { return &self; }
 548         LDKClosingTransaction* operator ->() { return &self; }
 549         const LDKClosingTransaction* operator &() const { return &self; }
 550         const LDKClosingTransaction* operator ->() const { return &self; }
 551 };
 552 class TrustedClosingTransaction {
 553 private:
 554         LDKTrustedClosingTransaction self;
 555 public:
 556         TrustedClosingTransaction(const TrustedClosingTransaction&) = delete;
 557         TrustedClosingTransaction(TrustedClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedClosingTransaction)); }
 558         TrustedClosingTransaction(LDKTrustedClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedClosingTransaction)); }
 559         operator LDKTrustedClosingTransaction() && { LDKTrustedClosingTransaction res = self; memset(&self, 0, sizeof(LDKTrustedClosingTransaction)); return res; }
 560         ~TrustedClosingTransaction() { TrustedClosingTransaction_free(self); }
 561         TrustedClosingTransaction& operator=(TrustedClosingTransaction&& o) { TrustedClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedClosingTransaction)); return *this; }
 562         LDKTrustedClosingTransaction* operator &() { return &self; }
 563         LDKTrustedClosingTransaction* operator ->() { return &self; }
 564         const LDKTrustedClosingTransaction* operator &() const { return &self; }
 565         const LDKTrustedClosingTransaction* operator ->() const { return &self; }
 566 };
 567 class CommitmentTransaction {
 568 private:
 569         LDKCommitmentTransaction self;
 570 public:
 571         CommitmentTransaction(const CommitmentTransaction&) = delete;
 572         CommitmentTransaction(CommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentTransaction)); }
 573         CommitmentTransaction(LDKCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentTransaction)); }
 574         operator LDKCommitmentTransaction() && { LDKCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKCommitmentTransaction)); return res; }
 575         ~CommitmentTransaction() { CommitmentTransaction_free(self); }
 576         CommitmentTransaction& operator=(CommitmentTransaction&& o) { CommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentTransaction)); return *this; }
 577         LDKCommitmentTransaction* operator &() { return &self; }
 578         LDKCommitmentTransaction* operator ->() { return &self; }
 579         const LDKCommitmentTransaction* operator &() const { return &self; }
 580         const LDKCommitmentTransaction* operator ->() const { return &self; }
 581 };
 582 class TrustedCommitmentTransaction {
 583 private:
 584         LDKTrustedCommitmentTransaction self;
 585 public:
 586         TrustedCommitmentTransaction(const TrustedCommitmentTransaction&) = delete;
 587         TrustedCommitmentTransaction(TrustedCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedCommitmentTransaction)); }
 588         TrustedCommitmentTransaction(LDKTrustedCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedCommitmentTransaction)); }
 589         operator LDKTrustedCommitmentTransaction() && { LDKTrustedCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKTrustedCommitmentTransaction)); return res; }
 590         ~TrustedCommitmentTransaction() { TrustedCommitmentTransaction_free(self); }
 591         TrustedCommitmentTransaction& operator=(TrustedCommitmentTransaction&& o) { TrustedCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedCommitmentTransaction)); return *this; }
 592         LDKTrustedCommitmentTransaction* operator &() { return &self; }
 593         LDKTrustedCommitmentTransaction* operator ->() { return &self; }
 594         const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
 595         const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
 596 };
 597 class ShutdownScript {
 598 private:
 599         LDKShutdownScript self;
 600 public:
 601         ShutdownScript(const ShutdownScript&) = delete;
 602         ShutdownScript(ShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(ShutdownScript)); }
 603         ShutdownScript(LDKShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdownScript)); }
 604         operator LDKShutdownScript() && { LDKShutdownScript res = self; memset(&self, 0, sizeof(LDKShutdownScript)); return res; }
 605         ~ShutdownScript() { ShutdownScript_free(self); }
 606         ShutdownScript& operator=(ShutdownScript&& o) { ShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(ShutdownScript)); return *this; }
 607         LDKShutdownScript* operator &() { return &self; }
 608         LDKShutdownScript* operator ->() { return &self; }
 609         const LDKShutdownScript* operator &() const { return &self; }
 610         const LDKShutdownScript* operator ->() const { return &self; }
 611 };
 612 class InvalidShutdownScript {
 613 private:
 614         LDKInvalidShutdownScript self;
 615 public:
 616         InvalidShutdownScript(const InvalidShutdownScript&) = delete;
 617         InvalidShutdownScript(InvalidShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(InvalidShutdownScript)); }
 618         InvalidShutdownScript(LDKInvalidShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvalidShutdownScript)); }
 619         operator LDKInvalidShutdownScript() && { LDKInvalidShutdownScript res = self; memset(&self, 0, sizeof(LDKInvalidShutdownScript)); return res; }
 620         ~InvalidShutdownScript() { InvalidShutdownScript_free(self); }
 621         InvalidShutdownScript& operator=(InvalidShutdownScript&& o) { InvalidShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(InvalidShutdownScript)); return *this; }
 622         LDKInvalidShutdownScript* operator &() { return &self; }
 623         LDKInvalidShutdownScript* operator ->() { return &self; }
 624         const LDKInvalidShutdownScript* operator &() const { return &self; }
 625         const LDKInvalidShutdownScript* operator ->() const { return &self; }
 626 };
 627 class BackgroundProcessor {
 628 private:
 629         LDKBackgroundProcessor self;
 630 public:
 631         BackgroundProcessor(const BackgroundProcessor&) = delete;
 632         BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
 633         BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
 634         operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
 635         ~BackgroundProcessor() { BackgroundProcessor_free(self); }
 636         BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
 637         LDKBackgroundProcessor* operator &() { return &self; }
 638         LDKBackgroundProcessor* operator ->() { return &self; }
 639         const LDKBackgroundProcessor* operator &() const { return &self; }
 640         const LDKBackgroundProcessor* operator ->() const { return &self; }
 641 };
 642 class ChannelManagerPersister {
 643 private:
 644         LDKChannelManagerPersister self;
 645 public:
 646         ChannelManagerPersister(const ChannelManagerPersister&) = delete;
 647         ChannelManagerPersister(ChannelManagerPersister&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerPersister)); }
 648         ChannelManagerPersister(LDKChannelManagerPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerPersister)); }
 649         operator LDKChannelManagerPersister() && { LDKChannelManagerPersister res = self; memset(&self, 0, sizeof(LDKChannelManagerPersister)); return res; }
 650         ~ChannelManagerPersister() { ChannelManagerPersister_free(self); }
 651         ChannelManagerPersister& operator=(ChannelManagerPersister&& o) { ChannelManagerPersister_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerPersister)); return *this; }
 652         LDKChannelManagerPersister* operator &() { return &self; }
 653         LDKChannelManagerPersister* operator ->() { return &self; }
 654         const LDKChannelManagerPersister* operator &() const { return &self; }
 655         const LDKChannelManagerPersister* operator ->() const { return &self; }
 656         /**
 657          *  Persist the given [`ChannelManager`] to disk, returning an error if persistence failed
 658          *  (which will cause the [`BackgroundProcessor`] which called this method to exit.
 659          *
 660          *  [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
 661          */
 662         inline LDK::CResult_NoneErrorZ persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager);
 663 };
 664 class RouteHop {
 665 private:
 666         LDKRouteHop self;
 667 public:
 668         RouteHop(const RouteHop&) = delete;
 669         RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
 670         RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
 671         operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
 672         ~RouteHop() { RouteHop_free(self); }
 673         RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
 674         LDKRouteHop* operator &() { return &self; }
 675         LDKRouteHop* operator ->() { return &self; }
 676         const LDKRouteHop* operator &() const { return &self; }
 677         const LDKRouteHop* operator ->() const { return &self; }
 678 };
 679 class Route {
 680 private:
 681         LDKRoute self;
 682 public:
 683         Route(const Route&) = delete;
 684         Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
 685         Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
 686         operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
 687         ~Route() { Route_free(self); }
 688         Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
 689         LDKRoute* operator &() { return &self; }
 690         LDKRoute* operator ->() { return &self; }
 691         const LDKRoute* operator &() const { return &self; }
 692         const LDKRoute* operator ->() const { return &self; }
 693 };
 694 class RouteParameters {
 695 private:
 696         LDKRouteParameters self;
 697 public:
 698         RouteParameters(const RouteParameters&) = delete;
 699         RouteParameters(RouteParameters&& o) : self(o.self) { memset(&o, 0, sizeof(RouteParameters)); }
 700         RouteParameters(LDKRouteParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteParameters)); }
 701         operator LDKRouteParameters() && { LDKRouteParameters res = self; memset(&self, 0, sizeof(LDKRouteParameters)); return res; }
 702         ~RouteParameters() { RouteParameters_free(self); }
 703         RouteParameters& operator=(RouteParameters&& o) { RouteParameters_free(self); self = o.self; memset(&o, 0, sizeof(RouteParameters)); return *this; }
 704         LDKRouteParameters* operator &() { return &self; }
 705         LDKRouteParameters* operator ->() { return &self; }
 706         const LDKRouteParameters* operator &() const { return &self; }
 707         const LDKRouteParameters* operator ->() const { return &self; }
 708 };
 709 class PaymentParameters {
 710 private:
 711         LDKPaymentParameters self;
 712 public:
 713         PaymentParameters(const PaymentParameters&) = delete;
 714         PaymentParameters(PaymentParameters&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentParameters)); }
 715         PaymentParameters(LDKPaymentParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentParameters)); }
 716         operator LDKPaymentParameters() && { LDKPaymentParameters res = self; memset(&self, 0, sizeof(LDKPaymentParameters)); return res; }
 717         ~PaymentParameters() { PaymentParameters_free(self); }
 718         PaymentParameters& operator=(PaymentParameters&& o) { PaymentParameters_free(self); self = o.self; memset(&o, 0, sizeof(PaymentParameters)); return *this; }
 719         LDKPaymentParameters* operator &() { return &self; }
 720         LDKPaymentParameters* operator ->() { return &self; }
 721         const LDKPaymentParameters* operator &() const { return &self; }
 722         const LDKPaymentParameters* operator ->() const { return &self; }
 723 };
 724 class RouteHint {
 725 private:
 726         LDKRouteHint self;
 727 public:
 728         RouteHint(const RouteHint&) = delete;
 729         RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
 730         RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
 731         operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
 732         ~RouteHint() { RouteHint_free(self); }
 733         RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
 734         LDKRouteHint* operator &() { return &self; }
 735         LDKRouteHint* operator ->() { return &self; }
 736         const LDKRouteHint* operator &() const { return &self; }
 737         const LDKRouteHint* operator ->() const { return &self; }
 738 };
 739 class RouteHintHop {
 740 private:
 741         LDKRouteHintHop self;
 742 public:
 743         RouteHintHop(const RouteHintHop&) = delete;
 744         RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
 745         RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
 746         operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
 747         ~RouteHintHop() { RouteHintHop_free(self); }
 748         RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
 749         LDKRouteHintHop* operator &() { return &self; }
 750         LDKRouteHintHop* operator ->() { return &self; }
 751         const LDKRouteHintHop* operator &() const { return &self; }
 752         const LDKRouteHintHop* operator ->() const { return &self; }
 753 };
 754 class BroadcasterInterface {
 755 private:
 756         LDKBroadcasterInterface self;
 757 public:
 758         BroadcasterInterface(const BroadcasterInterface&) = delete;
 759         BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
 760         BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
 761         operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
 762         ~BroadcasterInterface() { BroadcasterInterface_free(self); }
 763         BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
 764         LDKBroadcasterInterface* operator &() { return &self; }
 765         LDKBroadcasterInterface* operator ->() { return &self; }
 766         const LDKBroadcasterInterface* operator &() const { return &self; }
 767         const LDKBroadcasterInterface* operator ->() const { return &self; }
 768         /**
 769          *  Sends a transaction out to (hopefully) be mined.
 770          */
 771         inline void broadcast_transaction(struct LDKTransaction tx);
 772 };
 773 class ConfirmationTarget {
 774 private:
 775         LDKConfirmationTarget self;
 776 public:
 777         ConfirmationTarget(const ConfirmationTarget&) = delete;
 778         ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
 779         ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
 780         operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
 781         ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
 782         LDKConfirmationTarget* operator &() { return &self; }
 783         LDKConfirmationTarget* operator ->() { return &self; }
 784         const LDKConfirmationTarget* operator &() const { return &self; }
 785         const LDKConfirmationTarget* operator ->() const { return &self; }
 786 };
 787 class FeeEstimator {
 788 private:
 789         LDKFeeEstimator self;
 790 public:
 791         FeeEstimator(const FeeEstimator&) = delete;
 792         FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
 793         FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
 794         operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
 795         ~FeeEstimator() { FeeEstimator_free(self); }
 796         FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
 797         LDKFeeEstimator* operator &() { return &self; }
 798         LDKFeeEstimator* operator ->() { return &self; }
 799         const LDKFeeEstimator* operator &() const { return &self; }
 800         const LDKFeeEstimator* operator ->() const { return &self; }
 801         /**
 802          *  Gets estimated satoshis of fee required per 1000 Weight-Units.
 803          *
 804          *  Must return a value no smaller than 253 (ie 1 satoshi-per-byte rounded up to ensure later
 805          *  round-downs don't put us below 1 satoshi-per-byte).
 806          *
 807          *  This method can be implemented with the following unit conversions:
 808          *   * max(satoshis-per-byte * 250, 253)
 809          *   * max(satoshis-per-kbyte / 4, 253)
 810          */
 811         inline uint32_t get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target);
 812 };
 813 class BestBlock {
 814 private:
 815         LDKBestBlock self;
 816 public:
 817         BestBlock(const BestBlock&) = delete;
 818         BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
 819         BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
 820         operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
 821         ~BestBlock() { BestBlock_free(self); }
 822         BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
 823         LDKBestBlock* operator &() { return &self; }
 824         LDKBestBlock* operator ->() { return &self; }
 825         const LDKBestBlock* operator &() const { return &self; }
 826         const LDKBestBlock* operator ->() const { return &self; }
 827 };
 828 class AccessError {
 829 private:
 830         LDKAccessError self;
 831 public:
 832         AccessError(const AccessError&) = delete;
 833         AccessError(AccessError&& o) : self(o.self) { memset(&o, 0, sizeof(AccessError)); }
 834         AccessError(LDKAccessError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccessError)); }
 835         operator LDKAccessError() && { LDKAccessError res = self; memset(&self, 0, sizeof(LDKAccessError)); return res; }
 836         AccessError& operator=(AccessError&& o) { self = o.self; memset(&o, 0, sizeof(AccessError)); return *this; }
 837         LDKAccessError* operator &() { return &self; }
 838         LDKAccessError* operator ->() { return &self; }
 839         const LDKAccessError* operator &() const { return &self; }
 840         const LDKAccessError* operator ->() const { return &self; }
 841 };
 842 class Access {
 843 private:
 844         LDKAccess self;
 845 public:
 846         Access(const Access&) = delete;
 847         Access(Access&& o) : self(o.self) { memset(&o, 0, sizeof(Access)); }
 848         Access(LDKAccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccess)); }
 849         operator LDKAccess() && { LDKAccess res = self; memset(&self, 0, sizeof(LDKAccess)); return res; }
 850         ~Access() { Access_free(self); }
 851         Access& operator=(Access&& o) { Access_free(self); self = o.self; memset(&o, 0, sizeof(Access)); return *this; }
 852         LDKAccess* operator &() { return &self; }
 853         LDKAccess* operator ->() { return &self; }
 854         const LDKAccess* operator &() const { return &self; }
 855         const LDKAccess* operator ->() const { return &self; }
 856         /**
 857          *  Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
 858          *  Returns an error if `genesis_hash` is for a different chain or if such a transaction output
 859          *  is unknown.
 860          *
 861          *  [`short_channel_id`]: https://github.com/lightningnetwork/lightning-rfc/blob/master/07-routing-gossip.md#definition-of-short_channel_id
 862          */
 863         inline LDK::CResult_TxOutAccessErrorZ get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id);
 864 };
 865 class Listen {
 866 private:
 867         LDKListen self;
 868 public:
 869         Listen(const Listen&) = delete;
 870         Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
 871         Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
 872         operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
 873         ~Listen() { Listen_free(self); }
 874         Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
 875         LDKListen* operator &() { return &self; }
 876         LDKListen* operator ->() { return &self; }
 877         const LDKListen* operator &() const { return &self; }
 878         const LDKListen* operator ->() const { return &self; }
 879         /**
 880          *  Notifies the listener that a block was added at the given height.
 881          */
 882         inline void block_connected(struct LDKu8slice block, uint32_t height);
 883         /**
 884          *  Notifies the listener that a block was removed at the given height.
 885          */
 886         inline void block_disconnected(const uint8_t (*header)[80], uint32_t height);
 887 };
 888 class Confirm {
 889 private:
 890         LDKConfirm self;
 891 public:
 892         Confirm(const Confirm&) = delete;
 893         Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
 894         Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
 895         operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
 896         ~Confirm() { Confirm_free(self); }
 897         Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
 898         LDKConfirm* operator &() { return &self; }
 899         LDKConfirm* operator ->() { return &self; }
 900         const LDKConfirm* operator &() const { return &self; }
 901         const LDKConfirm* operator ->() const { return &self; }
 902         /**
 903          *  Processes transactions confirmed in a block with a given header and height.
 904          *
 905          *  Should be called for any transactions registered by [`Filter::register_tx`] or any
 906          *  transactions spending an output registered by [`Filter::register_output`]. Such transactions
 907          *  appearing in the same block do not need to be included in the same call; instead, multiple
 908          *  calls with additional transactions may be made so long as they are made in [chain order].
 909          *
 910          *  May be called before or after [`best_block_updated`] for the corresponding block. However,
 911          *  in the event of a chain reorganization, it must not be called with a `header` that is no
 912          *  longer in the chain as of the last call to [`best_block_updated`].
 913          *
 914          *  [chain order]: Confirm#Order
 915          *  [`best_block_updated`]: Self::best_block_updated
 916          */
 917         inline void transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
 918         /**
 919          *  Processes a transaction that is no longer confirmed as result of a chain reorganization.
 920          *
 921          *  Should be called for any transaction returned by [`get_relevant_txids`] if it has been
 922          *  reorganized out of the best chain. Once called, the given transaction should not be returned
 923          *  by [`get_relevant_txids`] unless it has been reconfirmed via [`transactions_confirmed`].
 924          *
 925          *  [`get_relevant_txids`]: Self::get_relevant_txids
 926          *  [`transactions_confirmed`]: Self::transactions_confirmed
 927          */
 928         inline void transaction_unconfirmed(const uint8_t (*txid)[32]);
 929         /**
 930          *  Processes an update to the best header connected at the given height.
 931          *
 932          *  Should be called when a new header is available but may be skipped for intermediary blocks
 933          *  if they become available at the same time.
 934          */
 935         inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
 936         /**
 937          *  Returns transactions that should be monitored for reorganization out of the chain.
 938          *
 939          *  Should include any transactions passed to [`transactions_confirmed`] that have insufficient
 940          *  confirmations to be safe from a chain reorganization. Should not include any transactions
 941          *  passed to [`transaction_unconfirmed`] unless later reconfirmed.
 942          *
 943          *  May be called to determine the subset of transactions that must still be monitored for
 944          *  reorganization. Will be idempotent between calls but may change as a result of calls to the
 945          *  other interface methods. Thus, this is useful to determine which transactions may need to be
 946          *  given to [`transaction_unconfirmed`].
 947          *
 948          *  [`transactions_confirmed`]: Self::transactions_confirmed
 949          *  [`transaction_unconfirmed`]: Self::transaction_unconfirmed
 950          */
 951         inline LDK::CVec_TxidZ get_relevant_txids();
 952 };
 953 class ChannelMonitorUpdateErr {
 954 private:
 955         LDKChannelMonitorUpdateErr self;
 956 public:
 957         ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete;
 958         ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); }
 959         ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); }
 960         operator LDKChannelMonitorUpdateErr() && { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; }
 961         ChannelMonitorUpdateErr& operator=(ChannelMonitorUpdateErr&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); return *this; }
 962         LDKChannelMonitorUpdateErr* operator &() { return &self; }
 963         LDKChannelMonitorUpdateErr* operator ->() { return &self; }
 964         const LDKChannelMonitorUpdateErr* operator &() const { return &self; }
 965         const LDKChannelMonitorUpdateErr* operator ->() const { return &self; }
 966 };
 967 class Watch {
 968 private:
 969         LDKWatch self;
 970 public:
 971         Watch(const Watch&) = delete;
 972         Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
 973         Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
 974         operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
 975         ~Watch() { Watch_free(self); }
 976         Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
 977         LDKWatch* operator &() { return &self; }
 978         LDKWatch* operator ->() { return &self; }
 979         const LDKWatch* operator &() const { return &self; }
 980         const LDKWatch* operator ->() const { return &self; }
 981         /**
 982          *  Watches a channel identified by `funding_txo` using `monitor`.
 983          *
 984          *  Implementations are responsible for watching the chain for the funding transaction along
 985          *  with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
 986          *  calling [`block_connected`] and [`block_disconnected`] on the monitor.
 987          *
 988          *  Note: this interface MUST error with `ChannelMonitorUpdateErr::PermanentFailure` if
 989          *  the given `funding_txo` has previously been registered via `watch_channel`.
 990          *
 991          *  [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
 992          *  [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
 993          *  [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
 994          */
 995         inline LDK::CResult_NoneChannelMonitorUpdateErrZ watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
 996         /**
 997          *  Updates a channel identified by `funding_txo` by applying `update` to its monitor.
 998          *
 999          *  Implementations must call [`update_monitor`] with the given update. See
1000          *  [`ChannelMonitorUpdateErr`] for invariants around returning an error.
1001          *
1002          *  [`update_monitor`]: channelmonitor::ChannelMonitor::update_monitor
1003          */
1004         inline LDK::CResult_NoneChannelMonitorUpdateErrZ update_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update);
1005         /**
1006          *  Returns any monitor events since the last call. Subsequent calls must only return new
1007          *  events.
1008          *
1009          *  Note that after any block- or transaction-connection calls to a [`ChannelMonitor`], no
1010          *  further events may be returned here until the [`ChannelMonitor`] has been fully persisted
1011          *  to disk.
1012          *
1013          *  For details on asynchronous [`ChannelMonitor`] updating and returning
1014          *  [`MonitorEvent::UpdateCompleted`] here, see [`ChannelMonitorUpdateErr::TemporaryFailure`].
1015          */
1016         inline LDK::CVec_MonitorEventZ release_pending_monitor_events();
1017 };
1018 class Filter {
1019 private:
1020         LDKFilter self;
1021 public:
1022         Filter(const Filter&) = delete;
1023         Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
1024         Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
1025         operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
1026         ~Filter() { Filter_free(self); }
1027         Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
1028         LDKFilter* operator &() { return &self; }
1029         LDKFilter* operator ->() { return &self; }
1030         const LDKFilter* operator &() const { return &self; }
1031         const LDKFilter* operator ->() const { return &self; }
1032         /**
1033          *  Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
1034          *  a spending condition.
1035          */
1036         inline void register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
1037         /**
1038          *  Registers interest in spends of a transaction output.
1039          *
1040          *  Optionally, when `output.block_hash` is set, should return any transaction spending the
1041          *  output that is found in the corresponding block along with its index.
1042          *
1043          *  This return value is useful for Electrum clients in order to supply in-block descendant
1044          *  transactions which otherwise were not included. This is not necessary for other clients if
1045          *  such descendant transactions were already included (e.g., when a BIP 157 client provides the
1046          *  full block).
1047          */
1048         inline LDK::COption_C2Tuple_usizeTransactionZZ register_output(struct LDKWatchedOutput output);
1049 };
1050 class WatchedOutput {
1051 private:
1052         LDKWatchedOutput self;
1053 public:
1054         WatchedOutput(const WatchedOutput&) = delete;
1055         WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
1056         WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
1057         operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
1058         ~WatchedOutput() { WatchedOutput_free(self); }
1059         WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
1060         LDKWatchedOutput* operator &() { return &self; }
1061         LDKWatchedOutput* operator ->() { return &self; }
1062         const LDKWatchedOutput* operator &() const { return &self; }
1063         const LDKWatchedOutput* operator ->() const { return &self; }
1064 };
1065 class PaymentPurpose {
1066 private:
1067         LDKPaymentPurpose self;
1068 public:
1069         PaymentPurpose(const PaymentPurpose&) = delete;
1070         PaymentPurpose(PaymentPurpose&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentPurpose)); }
1071         PaymentPurpose(LDKPaymentPurpose&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentPurpose)); }
1072         operator LDKPaymentPurpose() && { LDKPaymentPurpose res = self; memset(&self, 0, sizeof(LDKPaymentPurpose)); return res; }
1073         ~PaymentPurpose() { PaymentPurpose_free(self); }
1074         PaymentPurpose& operator=(PaymentPurpose&& o) { PaymentPurpose_free(self); self = o.self; memset(&o, 0, sizeof(PaymentPurpose)); return *this; }
1075         LDKPaymentPurpose* operator &() { return &self; }
1076         LDKPaymentPurpose* operator ->() { return &self; }
1077         const LDKPaymentPurpose* operator &() const { return &self; }
1078         const LDKPaymentPurpose* operator ->() const { return &self; }
1079 };
1080 class ClosureReason {
1081 private:
1082         LDKClosureReason self;
1083 public:
1084         ClosureReason(const ClosureReason&) = delete;
1085         ClosureReason(ClosureReason&& o) : self(o.self) { memset(&o, 0, sizeof(ClosureReason)); }
1086         ClosureReason(LDKClosureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosureReason)); }
1087         operator LDKClosureReason() && { LDKClosureReason res = self; memset(&self, 0, sizeof(LDKClosureReason)); return res; }
1088         ~ClosureReason() { ClosureReason_free(self); }
1089         ClosureReason& operator=(ClosureReason&& o) { ClosureReason_free(self); self = o.self; memset(&o, 0, sizeof(ClosureReason)); return *this; }
1090         LDKClosureReason* operator &() { return &self; }
1091         LDKClosureReason* operator ->() { return &self; }
1092         const LDKClosureReason* operator &() const { return &self; }
1093         const LDKClosureReason* operator ->() const { return &self; }
1094 };
1095 class Event {
1096 private:
1097         LDKEvent self;
1098 public:
1099         Event(const Event&) = delete;
1100         Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
1101         Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
1102         operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
1103         ~Event() { Event_free(self); }
1104         Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
1105         LDKEvent* operator &() { return &self; }
1106         LDKEvent* operator ->() { return &self; }
1107         const LDKEvent* operator &() const { return &self; }
1108         const LDKEvent* operator ->() const { return &self; }
1109 };
1110 class MessageSendEvent {
1111 private:
1112         LDKMessageSendEvent self;
1113 public:
1114         MessageSendEvent(const MessageSendEvent&) = delete;
1115         MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
1116         MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
1117         operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
1118         ~MessageSendEvent() { MessageSendEvent_free(self); }
1119         MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
1120         LDKMessageSendEvent* operator &() { return &self; }
1121         LDKMessageSendEvent* operator ->() { return &self; }
1122         const LDKMessageSendEvent* operator &() const { return &self; }
1123         const LDKMessageSendEvent* operator ->() const { return &self; }
1124 };
1125 class MessageSendEventsProvider {
1126 private:
1127         LDKMessageSendEventsProvider self;
1128 public:
1129         MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
1130         MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
1131         MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
1132         operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
1133         ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
1134         MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
1135         LDKMessageSendEventsProvider* operator &() { return &self; }
1136         LDKMessageSendEventsProvider* operator ->() { return &self; }
1137         const LDKMessageSendEventsProvider* operator &() const { return &self; }
1138         const LDKMessageSendEventsProvider* operator ->() const { return &self; }
1139         /**
1140          *  Gets the list of pending events which were generated by previous actions, clearing the list
1141          *  in the process.
1142          */
1143         inline LDK::CVec_MessageSendEventZ get_and_clear_pending_msg_events();
1144 };
1145 class EventsProvider {
1146 private:
1147         LDKEventsProvider self;
1148 public:
1149         EventsProvider(const EventsProvider&) = delete;
1150         EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
1151         EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
1152         operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
1153         ~EventsProvider() { EventsProvider_free(self); }
1154         EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
1155         LDKEventsProvider* operator &() { return &self; }
1156         LDKEventsProvider* operator ->() { return &self; }
1157         const LDKEventsProvider* operator &() const { return &self; }
1158         const LDKEventsProvider* operator ->() const { return &self; }
1159         /**
1160          *  Processes any events generated since the last call using the given event handler.
1161          *
1162          *  Subsequent calls must only process new events. However, handlers must be capable of handling
1163          *  duplicate events across process restarts. This may occur if the provider was recovered from
1164          *  an old state (i.e., it hadn't been successfully persisted after processing pending events).
1165          */
1166         inline void process_pending_events(struct LDKEventHandler handler);
1167 };
1168 class EventHandler {
1169 private:
1170         LDKEventHandler self;
1171 public:
1172         EventHandler(const EventHandler&) = delete;
1173         EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
1174         EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
1175         operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
1176         ~EventHandler() { EventHandler_free(self); }
1177         EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
1178         LDKEventHandler* operator &() { return &self; }
1179         LDKEventHandler* operator ->() { return &self; }
1180         const LDKEventHandler* operator &() const { return &self; }
1181         const LDKEventHandler* operator ->() const { return &self; }
1182         /**
1183          *  Handles the given [`Event`].
1184          *
1185          *  See [`EventsProvider`] for details that must be considered when implementing this method.
1186          */
1187         inline void handle_event(const struct LDKEvent *NONNULL_PTR event);
1188 };
1189 class Score {
1190 private:
1191         LDKScore self;
1192 public:
1193         Score(const Score&) = delete;
1194         Score(Score&& o) : self(o.self) { memset(&o, 0, sizeof(Score)); }
1195         Score(LDKScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScore)); }
1196         operator LDKScore() && { LDKScore res = self; memset(&self, 0, sizeof(LDKScore)); return res; }
1197         ~Score() { Score_free(self); }
1198         Score& operator=(Score&& o) { Score_free(self); self = o.self; memset(&o, 0, sizeof(Score)); return *this; }
1199         LDKScore* operator &() { return &self; }
1200         LDKScore* operator ->() { return &self; }
1201         const LDKScore* operator &() const { return &self; }
1202         const LDKScore* operator ->() const { return &self; }
1203         /**
1204          *  Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
1205          *  given channel in the direction from `source` to `target`.
1206          *
1207          *  The channel's capacity (less any other MPP parts that are also being considered for use in
1208          *  the same payment) is given by `capacity_msat`. It may be determined from various sources
1209          *  such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near
1210          *  [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
1211          *  Thus, implementations should be overflow-safe.
1212          */
1213         inline uint64_t channel_penalty_msat(uint64_t short_channel_id, uint64_t send_amt_msat, uint64_t capacity_msat, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target);
1214         /**
1215          *  Handles updating channel penalties after failing to route through a channel.
1216          */
1217         inline void payment_path_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id);
1218         /**
1219          *  Handles updating channel penalties after successfully routing along a path.
1220          */
1221         inline void payment_path_successful(struct LDKCVec_RouteHopZ path);
1222 };
1223 class LockableScore {
1224 private:
1225         LDKLockableScore self;
1226 public:
1227         LockableScore(const LockableScore&) = delete;
1228         LockableScore(LockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(LockableScore)); }
1229         LockableScore(LDKLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockableScore)); }
1230         operator LDKLockableScore() && { LDKLockableScore res = self; memset(&self, 0, sizeof(LDKLockableScore)); return res; }
1231         ~LockableScore() { LockableScore_free(self); }
1232         LockableScore& operator=(LockableScore&& o) { LockableScore_free(self); self = o.self; memset(&o, 0, sizeof(LockableScore)); return *this; }
1233         LDKLockableScore* operator &() { return &self; }
1234         LDKLockableScore* operator ->() { return &self; }
1235         const LDKLockableScore* operator &() const { return &self; }
1236         const LDKLockableScore* operator ->() const { return &self; }
1237         /**
1238          *  Returns the locked scorer.
1239          */
1240         inline LDK::Score lock();
1241 };
1242 class MultiThreadedLockableScore {
1243 private:
1244         LDKMultiThreadedLockableScore self;
1245 public:
1246         MultiThreadedLockableScore(const MultiThreadedLockableScore&) = delete;
1247         MultiThreadedLockableScore(MultiThreadedLockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedLockableScore)); }
1248         MultiThreadedLockableScore(LDKMultiThreadedLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedLockableScore)); }
1249         operator LDKMultiThreadedLockableScore() && { LDKMultiThreadedLockableScore res = self; memset(&self, 0, sizeof(LDKMultiThreadedLockableScore)); return res; }
1250         ~MultiThreadedLockableScore() { MultiThreadedLockableScore_free(self); }
1251         MultiThreadedLockableScore& operator=(MultiThreadedLockableScore&& o) { MultiThreadedLockableScore_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedLockableScore)); return *this; }
1252         LDKMultiThreadedLockableScore* operator &() { return &self; }
1253         LDKMultiThreadedLockableScore* operator ->() { return &self; }
1254         const LDKMultiThreadedLockableScore* operator &() const { return &self; }
1255         const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
1256 };
1257 class FixedPenaltyScorer {
1258 private:
1259         LDKFixedPenaltyScorer self;
1260 public:
1261         FixedPenaltyScorer(const FixedPenaltyScorer&) = delete;
1262         FixedPenaltyScorer(FixedPenaltyScorer&& o) : self(o.self) { memset(&o, 0, sizeof(FixedPenaltyScorer)); }
1263         FixedPenaltyScorer(LDKFixedPenaltyScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFixedPenaltyScorer)); }
1264         operator LDKFixedPenaltyScorer() && { LDKFixedPenaltyScorer res = self; memset(&self, 0, sizeof(LDKFixedPenaltyScorer)); return res; }
1265         ~FixedPenaltyScorer() { FixedPenaltyScorer_free(self); }
1266         FixedPenaltyScorer& operator=(FixedPenaltyScorer&& o) { FixedPenaltyScorer_free(self); self = o.self; memset(&o, 0, sizeof(FixedPenaltyScorer)); return *this; }
1267         LDKFixedPenaltyScorer* operator &() { return &self; }
1268         LDKFixedPenaltyScorer* operator ->() { return &self; }
1269         const LDKFixedPenaltyScorer* operator &() const { return &self; }
1270         const LDKFixedPenaltyScorer* operator ->() const { return &self; }
1271 };
1272 class Scorer {
1273 private:
1274         LDKScorer self;
1275 public:
1276         Scorer(const Scorer&) = delete;
1277         Scorer(Scorer&& o) : self(o.self) { memset(&o, 0, sizeof(Scorer)); }
1278         Scorer(LDKScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorer)); }
1279         operator LDKScorer() && { LDKScorer res = self; memset(&self, 0, sizeof(LDKScorer)); return res; }
1280         ~Scorer() { Scorer_free(self); }
1281         Scorer& operator=(Scorer&& o) { Scorer_free(self); self = o.self; memset(&o, 0, sizeof(Scorer)); return *this; }
1282         LDKScorer* operator &() { return &self; }
1283         LDKScorer* operator ->() { return &self; }
1284         const LDKScorer* operator &() const { return &self; }
1285         const LDKScorer* operator ->() const { return &self; }
1286 };
1287 class ScoringParameters {
1288 private:
1289         LDKScoringParameters self;
1290 public:
1291         ScoringParameters(const ScoringParameters&) = delete;
1292         ScoringParameters(ScoringParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ScoringParameters)); }
1293         ScoringParameters(LDKScoringParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoringParameters)); }
1294         operator LDKScoringParameters() && { LDKScoringParameters res = self; memset(&self, 0, sizeof(LDKScoringParameters)); return res; }
1295         ~ScoringParameters() { ScoringParameters_free(self); }
1296         ScoringParameters& operator=(ScoringParameters&& o) { ScoringParameters_free(self); self = o.self; memset(&o, 0, sizeof(ScoringParameters)); return *this; }
1297         LDKScoringParameters* operator &() { return &self; }
1298         LDKScoringParameters* operator ->() { return &self; }
1299         const LDKScoringParameters* operator &() const { return &self; }
1300         const LDKScoringParameters* operator ->() const { return &self; }
1301 };
1302 class ProbabilisticScorer {
1303 private:
1304         LDKProbabilisticScorer self;
1305 public:
1306         ProbabilisticScorer(const ProbabilisticScorer&) = delete;
1307         ProbabilisticScorer(ProbabilisticScorer&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScorer)); }
1308         ProbabilisticScorer(LDKProbabilisticScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScorer)); }
1309         operator LDKProbabilisticScorer() && { LDKProbabilisticScorer res = self; memset(&self, 0, sizeof(LDKProbabilisticScorer)); return res; }
1310         ~ProbabilisticScorer() { ProbabilisticScorer_free(self); }
1311         ProbabilisticScorer& operator=(ProbabilisticScorer&& o) { ProbabilisticScorer_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScorer)); return *this; }
1312         LDKProbabilisticScorer* operator &() { return &self; }
1313         LDKProbabilisticScorer* operator ->() { return &self; }
1314         const LDKProbabilisticScorer* operator &() const { return &self; }
1315         const LDKProbabilisticScorer* operator ->() const { return &self; }
1316 };
1317 class ProbabilisticScoringParameters {
1318 private:
1319         LDKProbabilisticScoringParameters self;
1320 public:
1321         ProbabilisticScoringParameters(const ProbabilisticScoringParameters&) = delete;
1322         ProbabilisticScoringParameters(ProbabilisticScoringParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringParameters)); }
1323         ProbabilisticScoringParameters(LDKProbabilisticScoringParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringParameters)); }
1324         operator LDKProbabilisticScoringParameters() && { LDKProbabilisticScoringParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringParameters)); return res; }
1325         ~ProbabilisticScoringParameters() { ProbabilisticScoringParameters_free(self); }
1326         ProbabilisticScoringParameters& operator=(ProbabilisticScoringParameters&& o) { ProbabilisticScoringParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringParameters)); return *this; }
1327         LDKProbabilisticScoringParameters* operator &() { return &self; }
1328         LDKProbabilisticScoringParameters* operator ->() { return &self; }
1329         const LDKProbabilisticScoringParameters* operator &() const { return &self; }
1330         const LDKProbabilisticScoringParameters* operator ->() const { return &self; }
1331 };
1332 class InitFeatures {
1333 private:
1334         LDKInitFeatures self;
1335 public:
1336         InitFeatures(const InitFeatures&) = delete;
1337         InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
1338         InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
1339         operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
1340         ~InitFeatures() { InitFeatures_free(self); }
1341         InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
1342         LDKInitFeatures* operator &() { return &self; }
1343         LDKInitFeatures* operator ->() { return &self; }
1344         const LDKInitFeatures* operator &() const { return &self; }
1345         const LDKInitFeatures* operator ->() const { return &self; }
1346 };
1347 class NodeFeatures {
1348 private:
1349         LDKNodeFeatures self;
1350 public:
1351         NodeFeatures(const NodeFeatures&) = delete;
1352         NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
1353         NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
1354         operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
1355         ~NodeFeatures() { NodeFeatures_free(self); }
1356         NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
1357         LDKNodeFeatures* operator &() { return &self; }
1358         LDKNodeFeatures* operator ->() { return &self; }
1359         const LDKNodeFeatures* operator &() const { return &self; }
1360         const LDKNodeFeatures* operator ->() const { return &self; }
1361 };
1362 class ChannelFeatures {
1363 private:
1364         LDKChannelFeatures self;
1365 public:
1366         ChannelFeatures(const ChannelFeatures&) = delete;
1367         ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
1368         ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
1369         operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
1370         ~ChannelFeatures() { ChannelFeatures_free(self); }
1371         ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
1372         LDKChannelFeatures* operator &() { return &self; }
1373         LDKChannelFeatures* operator ->() { return &self; }
1374         const LDKChannelFeatures* operator &() const { return &self; }
1375         const LDKChannelFeatures* operator ->() const { return &self; }
1376 };
1377 class InvoiceFeatures {
1378 private:
1379         LDKInvoiceFeatures self;
1380 public:
1381         InvoiceFeatures(const InvoiceFeatures&) = delete;
1382         InvoiceFeatures(InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceFeatures)); }
1383         InvoiceFeatures(LDKInvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceFeatures)); }
1384         operator LDKInvoiceFeatures() && { LDKInvoiceFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceFeatures)); return res; }
1385         ~InvoiceFeatures() { InvoiceFeatures_free(self); }
1386         InvoiceFeatures& operator=(InvoiceFeatures&& o) { InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceFeatures)); return *this; }
1387         LDKInvoiceFeatures* operator &() { return &self; }
1388         LDKInvoiceFeatures* operator ->() { return &self; }
1389         const LDKInvoiceFeatures* operator &() const { return &self; }
1390         const LDKInvoiceFeatures* operator ->() const { return &self; }
1391 };
1392 class ChannelTypeFeatures {
1393 private:
1394         LDKChannelTypeFeatures self;
1395 public:
1396         ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
1397         ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
1398         ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
1399         operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
1400         ~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
1401         ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
1402         LDKChannelTypeFeatures* operator &() { return &self; }
1403         LDKChannelTypeFeatures* operator ->() { return &self; }
1404         const LDKChannelTypeFeatures* operator &() const { return &self; }
1405         const LDKChannelTypeFeatures* operator ->() const { return &self; }
1406 };
1407 class DelayedPaymentOutputDescriptor {
1408 private:
1409         LDKDelayedPaymentOutputDescriptor self;
1410 public:
1411         DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
1412         DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
1413         DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
1414         operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
1415         ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
1416         DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
1417         LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
1418         LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
1419         const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
1420         const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
1421 };
1422 class StaticPaymentOutputDescriptor {
1423 private:
1424         LDKStaticPaymentOutputDescriptor self;
1425 public:
1426         StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
1427         StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
1428         StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
1429         operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
1430         ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
1431         StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
1432         LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
1433         LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
1434         const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
1435         const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
1436 };
1437 class SpendableOutputDescriptor {
1438 private:
1439         LDKSpendableOutputDescriptor self;
1440 public:
1441         SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
1442         SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
1443         SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
1444         operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
1445         ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
1446         SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
1447         LDKSpendableOutputDescriptor* operator &() { return &self; }
1448         LDKSpendableOutputDescriptor* operator ->() { return &self; }
1449         const LDKSpendableOutputDescriptor* operator &() const { return &self; }
1450         const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
1451 };
1452 class BaseSign {
1453 private:
1454         LDKBaseSign self;
1455 public:
1456         BaseSign(const BaseSign&) = delete;
1457         BaseSign(BaseSign&& o) : self(o.self) { memset(&o, 0, sizeof(BaseSign)); }
1458         BaseSign(LDKBaseSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBaseSign)); }
1459         operator LDKBaseSign() && { LDKBaseSign res = self; memset(&self, 0, sizeof(LDKBaseSign)); return res; }
1460         ~BaseSign() { BaseSign_free(self); }
1461         BaseSign& operator=(BaseSign&& o) { BaseSign_free(self); self = o.self; memset(&o, 0, sizeof(BaseSign)); return *this; }
1462         LDKBaseSign* operator &() { return &self; }
1463         LDKBaseSign* operator ->() { return &self; }
1464         const LDKBaseSign* operator &() const { return &self; }
1465         const LDKBaseSign* operator ->() const { return &self; }
1466         /**
1467          *  Gets the per-commitment point for a specific commitment number
1468          *
1469          *  Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
1470          */
1471         inline LDKPublicKey get_per_commitment_point(uint64_t idx);
1472         /**
1473          *  Gets the commitment secret for a specific commitment number as part of the revocation process
1474          *
1475          *  An external signer implementation should error here if the commitment was already signed
1476          *  and should refuse to sign it in the future.
1477          *
1478          *  May be called more than once for the same index.
1479          *
1480          *  Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
1481          */
1482         inline LDKThirtyTwoBytes release_commitment_secret(uint64_t idx);
1483         /**
1484          *  Validate the counterparty's signatures on the holder commitment transaction and HTLCs.
1485          *
1486          *  This is required in order for the signer to make sure that releasing a commitment
1487          *  secret won't leave us without a broadcastable holder transaction.
1488          *  Policy checks should be implemented in this function, including checking the amount
1489          *  sent to us and checking the HTLCs.
1490          *
1491          *  The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
1492          *  A validating signer should ensure that an HTLC output is removed only when the matching
1493          *  preimage is provided, or when the value to holder is restored.
1494          *
1495          *  NOTE: all the relevant preimages will be provided, but there may also be additional
1496          *  irrelevant or duplicate preimages.
1497          */
1498         inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages);
1499         /**
1500          *  Gets an arbitrary identifier describing the set of keys which are provided back to you in
1501          *  some SpendableOutputDescriptor types. This should be sufficient to identify this
1502          *  Sign object uniquely and lookup or re-derive its keys.
1503          */
1504         inline LDKThirtyTwoBytes channel_keys_id();
1505         /**
1506          *  Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
1507          *
1508          *  Note that if signing fails or is rejected, the channel will be force-closed.
1509          *
1510          *  Policy checks should be implemented in this function, including checking the amount
1511          *  sent to us and checking the HTLCs.
1512          *
1513          *  The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
1514          *  A validating signer should ensure that an HTLC output is removed only when the matching
1515          *  preimage is provided, or when the value to holder is restored.
1516          *
1517          *  NOTE: all the relevant preimages will be provided, but there may also be additional
1518          *  irrelevant or duplicate preimages.
1519          */
1520         inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages);
1521         /**
1522          *  Validate the counterparty's revocation.
1523          *
1524          *  This is required in order for the signer to make sure that the state has moved
1525          *  forward and it is safe to sign the next counterparty commitment.
1526          */
1527         inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
1528         /**
1529          *  Create a signatures for a holder's commitment transaction and its claiming HTLC transactions.
1530          *  This will only ever be called with a non-revoked commitment_tx.  This will be called with the
1531          *  latest commitment_tx when we initiate a force-close.
1532          *  This will be called with the previous latest, just to get claiming HTLC signatures, if we are
1533          *  reacting to a ChannelMonitor replica that decided to broadcast before it had been updated to
1534          *  the latest.
1535          *  This may be called multiple times for the same transaction.
1536          *
1537          *  An external signer implementation should check that the commitment has not been revoked.
1538          *
1539          *  May return Err if key derivation fails.  Callers, such as ChannelMonitor, will panic in such a case.
1540          */
1541         inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
1542         /**
1543          *  Create a signature for the given input in a transaction spending an HTLC transaction output
1544          *  or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
1545          *
1546          *  A justice transaction may claim multiple outputs at the same time if timelocks are
1547          *  similar, but only a signature for the input at index `input` should be signed for here.
1548          *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
1549          *  to an upcoming timelock expiration.
1550          *
1551          *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
1552          *
1553          *  per_commitment_key is revocation secret which was provided by our counterparty when they
1554          *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
1555          *  not allow the spending of any funds by itself (you need our holder revocation_secret to do
1556          *  so).
1557          */
1558         inline LDK::CResult_SignatureNoneZ sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]);
1559         /**
1560          *  Create a signature for the given input in a transaction spending a commitment transaction
1561          *  HTLC output when our counterparty broadcasts an old state.
1562          *
1563          *  A justice transaction may claim multiple outputs at the same time if timelocks are
1564          *  similar, but only a signature for the input at index `input` should be signed for here.
1565          *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
1566          *  to an upcoming timelock expiration.
1567          *
1568          *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
1569          *
1570          *  per_commitment_key is revocation secret which was provided by our counterparty when they
1571          *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
1572          *  not allow the spending of any funds by itself (you need our holder revocation_secret to do
1573          *  so).
1574          *
1575          *  htlc holds HTLC elements (hash, timelock), thus changing the format of the witness script
1576          *  (which is committed to in the BIP 143 signatures).
1577          */
1578         inline LDK::CResult_SignatureNoneZ sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
1579         /**
1580          *  Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
1581          *  transaction, either offered or received.
1582          *
1583          *  Such a transaction may claim multiples offered outputs at same time if we know the
1584          *  preimage for each when we create it, but only the input at index `input` should be
1585          *  signed for here. It may be called multiple times for same output(s) if a fee-bump is
1586          *  needed with regards to an upcoming timelock expiration.
1587          *
1588          *  Witness_script is either a offered or received script as defined in BOLT3 for HTLC
1589          *  outputs.
1590          *
1591          *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
1592          *
1593          *  Per_commitment_point is the dynamic point corresponding to the channel state
1594          *  detected onchain. It has been generated by our counterparty and is used to derive
1595          *  channel state keys, which are then included in the witness script and committed to in the
1596          *  BIP 143 signature.
1597          */
1598         inline LDK::CResult_SignatureNoneZ sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
1599         /**
1600          *  Create a signature for a (proposed) closing transaction.
1601          *
1602          *  Note that, due to rounding, there may be one "missing" satoshi, and either party may have
1603          *  chosen to forgo their output as dust.
1604          */
1605         inline LDK::CResult_SignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
1606         /**
1607          *  Signs a channel announcement message with our funding key and our node secret key (aka
1608          *  node_id or network_key), proving it comes from one of the channel participants.
1609          *
1610          *  The first returned signature should be from our node secret key, the second from our
1611          *  funding key.
1612          *
1613          *  Note that if this fails or is rejected, the channel will not be publicly announced and
1614          *  our counterparty may (though likely will not) close the channel on us for violating the
1615          *  protocol.
1616          */
1617         inline LDK::CResult_C2Tuple_SignatureSignatureZNoneZ sign_channel_announcement(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
1618         /**
1619          *  Set the counterparty static channel data, including basepoints,
1620          *  counterparty_selected/holder_selected_contest_delay and funding outpoint.
1621          *  This is done as soon as the funding outpoint is known.  Since these are static channel data,
1622          *  they MUST NOT be allowed to change to different values once set.
1623          *
1624          *  channel_parameters.is_populated() MUST be true.
1625          *
1626          *  We bind holder_selected_contest_delay late here for API convenience.
1627          *
1628          *  Will be called before any signatures are applied.
1629          */
1630         inline void ready_channel(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
1631 };
1632 class Sign {
1633 private:
1634         LDKSign self;
1635 public:
1636         Sign(const Sign&) = delete;
1637         Sign(Sign&& o) : self(o.self) { memset(&o, 0, sizeof(Sign)); }
1638         Sign(LDKSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSign)); }
1639         operator LDKSign() && { LDKSign res = self; memset(&self, 0, sizeof(LDKSign)); return res; }
1640         ~Sign() { Sign_free(self); }
1641         Sign& operator=(Sign&& o) { Sign_free(self); self = o.self; memset(&o, 0, sizeof(Sign)); return *this; }
1642         LDKSign* operator &() { return &self; }
1643         LDKSign* operator ->() { return &self; }
1644         const LDKSign* operator &() const { return &self; }
1645         const LDKSign* operator ->() const { return &self; }
1646 };
1647 class Recipient {
1648 private:
1649         LDKRecipient self;
1650 public:
1651         Recipient(const Recipient&) = delete;
1652         Recipient(Recipient&& o) : self(o.self) { memset(&o, 0, sizeof(Recipient)); }
1653         Recipient(LDKRecipient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipient)); }
1654         operator LDKRecipient() && { LDKRecipient res = self; memset(&self, 0, sizeof(LDKRecipient)); return res; }
1655         Recipient& operator=(Recipient&& o) { self = o.self; memset(&o, 0, sizeof(Recipient)); return *this; }
1656         LDKRecipient* operator &() { return &self; }
1657         LDKRecipient* operator ->() { return &self; }
1658         const LDKRecipient* operator &() const { return &self; }
1659         const LDKRecipient* operator ->() const { return &self; }
1660 };
1661 class KeysInterface {
1662 private:
1663         LDKKeysInterface self;
1664 public:
1665         KeysInterface(const KeysInterface&) = delete;
1666         KeysInterface(KeysInterface&& o) : self(o.self) { memset(&o, 0, sizeof(KeysInterface)); }
1667         KeysInterface(LDKKeysInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysInterface)); }
1668         operator LDKKeysInterface() && { LDKKeysInterface res = self; memset(&self, 0, sizeof(LDKKeysInterface)); return res; }
1669         ~KeysInterface() { KeysInterface_free(self); }
1670         KeysInterface& operator=(KeysInterface&& o) { KeysInterface_free(self); self = o.self; memset(&o, 0, sizeof(KeysInterface)); return *this; }
1671         LDKKeysInterface* operator &() { return &self; }
1672         LDKKeysInterface* operator ->() { return &self; }
1673         const LDKKeysInterface* operator &() const { return &self; }
1674         const LDKKeysInterface* operator ->() const { return &self; }
1675         /**
1676          *  Get node secret key (aka node_id or network_key) based on the provided [`Recipient`].
1677          *
1678          *  This method must return the same value each time it is called with a given `Recipient`
1679          *  parameter.
1680          */
1681         inline LDK::CResult_SecretKeyNoneZ get_node_secret(enum LDKRecipient recipient);
1682         /**
1683          *  Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
1684          *
1685          *  This method should return a different value each time it is called, to avoid linking
1686          *  on-chain funds across channels as controlled to the same user.
1687          */
1688         inline LDK::CVec_u8Z get_destination_script();
1689         /**
1690          *  Get a script pubkey which we will send funds to when closing a channel.
1691          *
1692          *  This method should return a different value each time it is called, to avoid linking
1693          *  on-chain funds across channels as controlled to the same user.
1694          */
1695         inline LDK::ShutdownScript get_shutdown_scriptpubkey();
1696         /**
1697          *  Get a new set of Sign for per-channel secrets. These MUST be unique even if you
1698          *  restarted with some stale data!
1699          *
1700          *  This method must return a different value each time it is called.
1701          */
1702         inline LDK::Sign get_channel_signer(bool inbound, uint64_t channel_value_satoshis);
1703         /**
1704          *  Gets a unique, cryptographically-secure, random 32 byte value. This is used for encrypting
1705          *  onion packets and for temporary channel IDs. There is no requirement that these be
1706          *  persisted anywhere, though they must be unique across restarts.
1707          *
1708          *  This method must return a different value each time it is called.
1709          */
1710         inline LDKThirtyTwoBytes get_secure_random_bytes();
1711         /**
1712          *  Reads a `Signer` for this `KeysInterface` from the given input stream.
1713          *  This is only called during deserialization of other objects which contain
1714          *  `Sign`-implementing objects (ie `ChannelMonitor`s and `ChannelManager`s).
1715          *  The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
1716          *  contain no versioning scheme. You may wish to include your own version prefix and ensure
1717          *  you've read all of the provided bytes to ensure no corruption occurred.
1718          */
1719         inline LDK::CResult_SignDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
1720         /**
1721          *  Sign an invoice.
1722          *  By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
1723          *  this trait to parse the invoice and make sure they're signing what they expect, rather than
1724          *  blindly signing the hash.
1725          *  The hrp is ascii bytes, while the invoice data is base32.
1726          *
1727          *  The secret key used to sign the invoice is dependent on the [`Recipient`].
1728          */
1729         inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient);
1730         /**
1731          *  Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
1732          *
1733          *  If the implementor of this trait supports [phantom node payments], then every node that is
1734          *  intended to be included in the phantom invoice route hints must return the same value from
1735          *  this method.
1736          *
1737          *  This method must return the same value each time it is called.
1738          *
1739          *  [phantom node payments]: PhantomKeysManager
1740          */
1741         inline LDKThirtyTwoBytes get_inbound_payment_key_material();
1742 };
1743 class InMemorySigner {
1744 private:
1745         LDKInMemorySigner self;
1746 public:
1747         InMemorySigner(const InMemorySigner&) = delete;
1748         InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
1749         InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
1750         operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
1751         ~InMemorySigner() { InMemorySigner_free(self); }
1752         InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
1753         LDKInMemorySigner* operator &() { return &self; }
1754         LDKInMemorySigner* operator ->() { return &self; }
1755         const LDKInMemorySigner* operator &() const { return &self; }
1756         const LDKInMemorySigner* operator ->() const { return &self; }
1757 };
1758 class KeysManager {
1759 private:
1760         LDKKeysManager self;
1761 public:
1762         KeysManager(const KeysManager&) = delete;
1763         KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
1764         KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
1765         operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
1766         ~KeysManager() { KeysManager_free(self); }
1767         KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
1768         LDKKeysManager* operator &() { return &self; }
1769         LDKKeysManager* operator ->() { return &self; }
1770         const LDKKeysManager* operator &() const { return &self; }
1771         const LDKKeysManager* operator ->() const { return &self; }
1772 };
1773 class PhantomKeysManager {
1774 private:
1775         LDKPhantomKeysManager self;
1776 public:
1777         PhantomKeysManager(const PhantomKeysManager&) = delete;
1778         PhantomKeysManager(PhantomKeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomKeysManager)); }
1779         PhantomKeysManager(LDKPhantomKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomKeysManager)); }
1780         operator LDKPhantomKeysManager() && { LDKPhantomKeysManager res = self; memset(&self, 0, sizeof(LDKPhantomKeysManager)); return res; }
1781         ~PhantomKeysManager() { PhantomKeysManager_free(self); }
1782         PhantomKeysManager& operator=(PhantomKeysManager&& o) { PhantomKeysManager_free(self); self = o.self; memset(&o, 0, sizeof(PhantomKeysManager)); return *this; }
1783         LDKPhantomKeysManager* operator &() { return &self; }
1784         LDKPhantomKeysManager* operator ->() { return &self; }
1785         const LDKPhantomKeysManager* operator &() const { return &self; }
1786         const LDKPhantomKeysManager* operator ->() const { return &self; }
1787 };
1788 class FilesystemPersister {
1789 private:
1790         LDKFilesystemPersister self;
1791 public:
1792         FilesystemPersister(const FilesystemPersister&) = delete;
1793         FilesystemPersister(FilesystemPersister&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemPersister)); }
1794         FilesystemPersister(LDKFilesystemPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemPersister)); }
1795         operator LDKFilesystemPersister() && { LDKFilesystemPersister res = self; memset(&self, 0, sizeof(LDKFilesystemPersister)); return res; }
1796         ~FilesystemPersister() { FilesystemPersister_free(self); }
1797         FilesystemPersister& operator=(FilesystemPersister&& o) { FilesystemPersister_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemPersister)); return *this; }
1798         LDKFilesystemPersister* operator &() { return &self; }
1799         LDKFilesystemPersister* operator ->() { return &self; }
1800         const LDKFilesystemPersister* operator &() const { return &self; }
1801         const LDKFilesystemPersister* operator ->() const { return &self; }
1802 };
1803 class ChannelManager {
1804 private:
1805         LDKChannelManager self;
1806 public:
1807         ChannelManager(const ChannelManager&) = delete;
1808         ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
1809         ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
1810         operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
1811         ~ChannelManager() { ChannelManager_free(self); }
1812         ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
1813         LDKChannelManager* operator &() { return &self; }
1814         LDKChannelManager* operator ->() { return &self; }
1815         const LDKChannelManager* operator &() const { return &self; }
1816         const LDKChannelManager* operator ->() const { return &self; }
1817 };
1818 class ChainParameters {
1819 private:
1820         LDKChainParameters self;
1821 public:
1822         ChainParameters(const ChainParameters&) = delete;
1823         ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
1824         ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
1825         operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
1826         ~ChainParameters() { ChainParameters_free(self); }
1827         ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
1828         LDKChainParameters* operator &() { return &self; }
1829         LDKChainParameters* operator ->() { return &self; }
1830         const LDKChainParameters* operator &() const { return &self; }
1831         const LDKChainParameters* operator ->() const { return &self; }
1832 };
1833 class CounterpartyForwardingInfo {
1834 private:
1835         LDKCounterpartyForwardingInfo self;
1836 public:
1837         CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
1838         CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
1839         CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
1840         operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
1841         ~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
1842         CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
1843         LDKCounterpartyForwardingInfo* operator &() { return &self; }
1844         LDKCounterpartyForwardingInfo* operator ->() { return &self; }
1845         const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
1846         const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
1847 };
1848 class ChannelCounterparty {
1849 private:
1850         LDKChannelCounterparty self;
1851 public:
1852         ChannelCounterparty(const ChannelCounterparty&) = delete;
1853         ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
1854         ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
1855         operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
1856         ~ChannelCounterparty() { ChannelCounterparty_free(self); }
1857         ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
1858         LDKChannelCounterparty* operator &() { return &self; }
1859         LDKChannelCounterparty* operator ->() { return &self; }
1860         const LDKChannelCounterparty* operator &() const { return &self; }
1861         const LDKChannelCounterparty* operator ->() const { return &self; }
1862 };
1863 class ChannelDetails {
1864 private:
1865         LDKChannelDetails self;
1866 public:
1867         ChannelDetails(const ChannelDetails&) = delete;
1868         ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
1869         ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
1870         operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
1871         ~ChannelDetails() { ChannelDetails_free(self); }
1872         ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
1873         LDKChannelDetails* operator &() { return &self; }
1874         LDKChannelDetails* operator ->() { return &self; }
1875         const LDKChannelDetails* operator &() const { return &self; }
1876         const LDKChannelDetails* operator ->() const { return &self; }
1877 };
1878 class PaymentSendFailure {
1879 private:
1880         LDKPaymentSendFailure self;
1881 public:
1882         PaymentSendFailure(const PaymentSendFailure&) = delete;
1883         PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
1884         PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
1885         operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
1886         ~PaymentSendFailure() { PaymentSendFailure_free(self); }
1887         PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
1888         LDKPaymentSendFailure* operator &() { return &self; }
1889         LDKPaymentSendFailure* operator ->() { return &self; }
1890         const LDKPaymentSendFailure* operator &() const { return &self; }
1891         const LDKPaymentSendFailure* operator ->() const { return &self; }
1892 };
1893 class PhantomRouteHints {
1894 private:
1895         LDKPhantomRouteHints self;
1896 public:
1897         PhantomRouteHints(const PhantomRouteHints&) = delete;
1898         PhantomRouteHints(PhantomRouteHints&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomRouteHints)); }
1899         PhantomRouteHints(LDKPhantomRouteHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomRouteHints)); }
1900         operator LDKPhantomRouteHints() && { LDKPhantomRouteHints res = self; memset(&self, 0, sizeof(LDKPhantomRouteHints)); return res; }
1901         ~PhantomRouteHints() { PhantomRouteHints_free(self); }
1902         PhantomRouteHints& operator=(PhantomRouteHints&& o) { PhantomRouteHints_free(self); self = o.self; memset(&o, 0, sizeof(PhantomRouteHints)); return *this; }
1903         LDKPhantomRouteHints* operator &() { return &self; }
1904         LDKPhantomRouteHints* operator ->() { return &self; }
1905         const LDKPhantomRouteHints* operator &() const { return &self; }
1906         const LDKPhantomRouteHints* operator ->() const { return &self; }
1907 };
1908 class ChannelManagerReadArgs {
1909 private:
1910         LDKChannelManagerReadArgs self;
1911 public:
1912         ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
1913         ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
1914         ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
1915         operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
1916         ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
1917         ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
1918         LDKChannelManagerReadArgs* operator &() { return &self; }
1919         LDKChannelManagerReadArgs* operator ->() { return &self; }
1920         const LDKChannelManagerReadArgs* operator &() const { return &self; }
1921         const LDKChannelManagerReadArgs* operator ->() const { return &self; }
1922 };
1923 class ChannelHandshakeConfig {
1924 private:
1925         LDKChannelHandshakeConfig self;
1926 public:
1927         ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
1928         ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
1929         ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
1930         operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
1931         ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
1932         ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
1933         LDKChannelHandshakeConfig* operator &() { return &self; }
1934         LDKChannelHandshakeConfig* operator ->() { return &self; }
1935         const LDKChannelHandshakeConfig* operator &() const { return &self; }
1936         const LDKChannelHandshakeConfig* operator ->() const { return &self; }
1937 };
1938 class ChannelHandshakeLimits {
1939 private:
1940         LDKChannelHandshakeLimits self;
1941 public:
1942         ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
1943         ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
1944         ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
1945         operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
1946         ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
1947         ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
1948         LDKChannelHandshakeLimits* operator &() { return &self; }
1949         LDKChannelHandshakeLimits* operator ->() { return &self; }
1950         const LDKChannelHandshakeLimits* operator &() const { return &self; }
1951         const LDKChannelHandshakeLimits* operator ->() const { return &self; }
1952 };
1953 class ChannelConfig {
1954 private:
1955         LDKChannelConfig self;
1956 public:
1957         ChannelConfig(const ChannelConfig&) = delete;
1958         ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
1959         ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
1960         operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
1961         ~ChannelConfig() { ChannelConfig_free(self); }
1962         ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
1963         LDKChannelConfig* operator &() { return &self; }
1964         LDKChannelConfig* operator ->() { return &self; }
1965         const LDKChannelConfig* operator &() const { return &self; }
1966         const LDKChannelConfig* operator ->() const { return &self; }
1967 };
1968 class UserConfig {
1969 private:
1970         LDKUserConfig self;
1971 public:
1972         UserConfig(const UserConfig&) = delete;
1973         UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
1974         UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
1975         operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
1976         ~UserConfig() { UserConfig_free(self); }
1977         UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
1978         LDKUserConfig* operator &() { return &self; }
1979         LDKUserConfig* operator ->() { return &self; }
1980         const LDKUserConfig* operator &() const { return &self; }
1981         const LDKUserConfig* operator ->() const { return &self; }
1982 };
1983 class APIError {
1984 private:
1985         LDKAPIError self;
1986 public:
1987         APIError(const APIError&) = delete;
1988         APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
1989         APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
1990         operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
1991         ~APIError() { APIError_free(self); }
1992         APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
1993         LDKAPIError* operator &() { return &self; }
1994         LDKAPIError* operator ->() { return &self; }
1995         const LDKAPIError* operator &() const { return &self; }
1996         const LDKAPIError* operator ->() const { return &self; }
1997 };
1998 class OutPoint {
1999 private:
2000         LDKOutPoint self;
2001 public:
2002         OutPoint(const OutPoint&) = delete;
2003         OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
2004         OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
2005         operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
2006         ~OutPoint() { OutPoint_free(self); }
2007         OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
2008         LDKOutPoint* operator &() { return &self; }
2009         LDKOutPoint* operator ->() { return &self; }
2010         const LDKOutPoint* operator &() const { return &self; }
2011         const LDKOutPoint* operator ->() const { return &self; }
2012 };
2013 class CustomMessageReader {
2014 private:
2015         LDKCustomMessageReader self;
2016 public:
2017         CustomMessageReader(const CustomMessageReader&) = delete;
2018         CustomMessageReader(CustomMessageReader&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageReader)); }
2019         CustomMessageReader(LDKCustomMessageReader&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageReader)); }
2020         operator LDKCustomMessageReader() && { LDKCustomMessageReader res = self; memset(&self, 0, sizeof(LDKCustomMessageReader)); return res; }
2021         ~CustomMessageReader() { CustomMessageReader_free(self); }
2022         CustomMessageReader& operator=(CustomMessageReader&& o) { CustomMessageReader_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageReader)); return *this; }
2023         LDKCustomMessageReader* operator &() { return &self; }
2024         LDKCustomMessageReader* operator ->() { return &self; }
2025         const LDKCustomMessageReader* operator &() const { return &self; }
2026         const LDKCustomMessageReader* operator ->() const { return &self; }
2027         /**
2028          *  Decodes a custom message to `CustomMessageType`. If the given message type is known to the
2029          *  implementation and the message could be decoded, must return `Ok(Some(message))`. If the
2030          *  message type is unknown to the implementation, must return `Ok(None)`. If a decoding error
2031          *  occur, must return `Err(DecodeError::X)` where `X` details the encountered error.
2032          */
2033         inline LDK::CResult_COption_TypeZDecodeErrorZ read(uint16_t message_type, struct LDKu8slice buffer);
2034 };
2035 class Type {
2036 private:
2037         LDKType self;
2038 public:
2039         Type(const Type&) = delete;
2040         Type(Type&& o) : self(o.self) { memset(&o, 0, sizeof(Type)); }
2041         Type(LDKType&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKType)); }
2042         operator LDKType() && { LDKType res = self; memset(&self, 0, sizeof(LDKType)); return res; }
2043         ~Type() { Type_free(self); }
2044         Type& operator=(Type&& o) { Type_free(self); self = o.self; memset(&o, 0, sizeof(Type)); return *this; }
2045         LDKType* operator &() { return &self; }
2046         LDKType* operator ->() { return &self; }
2047         const LDKType* operator &() const { return &self; }
2048         const LDKType* operator ->() const { return &self; }
2049         /**
2050          *  Returns the type identifying the message payload.
2051          */
2052         inline uint16_t type_id();
2053         /**
2054          * Return a human-readable "debug" string describing this object
2055          */
2056         inline LDK::Str debug_str();
2057 };
2058 class InvoicePayer {
2059 private:
2060         LDKInvoicePayer self;
2061 public:
2062         InvoicePayer(const InvoicePayer&) = delete;
2063         InvoicePayer(InvoicePayer&& o) : self(o.self) { memset(&o, 0, sizeof(InvoicePayer)); }
2064         InvoicePayer(LDKInvoicePayer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoicePayer)); }
2065         operator LDKInvoicePayer() && { LDKInvoicePayer res = self; memset(&self, 0, sizeof(LDKInvoicePayer)); return res; }
2066         ~InvoicePayer() { InvoicePayer_free(self); }
2067         InvoicePayer& operator=(InvoicePayer&& o) { InvoicePayer_free(self); self = o.self; memset(&o, 0, sizeof(InvoicePayer)); return *this; }
2068         LDKInvoicePayer* operator &() { return &self; }
2069         LDKInvoicePayer* operator ->() { return &self; }
2070         const LDKInvoicePayer* operator &() const { return &self; }
2071         const LDKInvoicePayer* operator ->() const { return &self; }
2072 };
2073 class Payer {
2074 private:
2075         LDKPayer self;
2076 public:
2077         Payer(const Payer&) = delete;
2078         Payer(Payer&& o) : self(o.self) { memset(&o, 0, sizeof(Payer)); }
2079         Payer(LDKPayer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayer)); }
2080         operator LDKPayer() && { LDKPayer res = self; memset(&self, 0, sizeof(LDKPayer)); return res; }
2081         ~Payer() { Payer_free(self); }
2082         Payer& operator=(Payer&& o) { Payer_free(self); self = o.self; memset(&o, 0, sizeof(Payer)); return *this; }
2083         LDKPayer* operator &() { return &self; }
2084         LDKPayer* operator ->() { return &self; }
2085         const LDKPayer* operator &() const { return &self; }
2086         const LDKPayer* operator ->() const { return &self; }
2087         /**
2088          *  Returns the payer's node id.
2089          */
2090         inline LDKPublicKey node_id();
2091         /**
2092          *  Returns the payer's channels.
2093          */
2094         inline LDK::CVec_ChannelDetailsZ first_hops();
2095         /**
2096          *  Sends a payment over the Lightning Network using the given [`Route`].
2097          *
2098          *  Note that payment_secret (or a relevant inner pointer) may be NULL or all-0s to represent None
2099          */
2100         inline LDK::CResult_PaymentIdPaymentSendFailureZ send_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
2101         /**
2102          *  Sends a spontaneous payment over the Lightning Network using the given [`Route`].
2103          */
2104         inline LDK::CResult_PaymentIdPaymentSendFailureZ send_spontaneous_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage);
2105         /**
2106          *  Retries a failed payment path for the [`PaymentId`] using the given [`Route`].
2107          */
2108         inline LDK::CResult_NonePaymentSendFailureZ retry_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id);
2109         /**
2110          *  Signals that no further retries for the given payment will occur.
2111          */
2112         inline void abandon_payment(struct LDKThirtyTwoBytes payment_id);
2113 };
2114 class Router {
2115 private:
2116         LDKRouter self;
2117 public:
2118         Router(const Router&) = delete;
2119         Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
2120         Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
2121         operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
2122         ~Router() { Router_free(self); }
2123         Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
2124         LDKRouter* operator &() { return &self; }
2125         LDKRouter* operator ->() { return &self; }
2126         const LDKRouter* operator &() const { return &self; }
2127         const LDKRouter* operator ->() const { return &self; }
2128         /**
2129          *  Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
2130          *
2131          *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
2132          */
2133         inline LDK::CResult_RouteLightningErrorZ find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKScore *NONNULL_PTR scorer);
2134 };
2135 class RetryAttempts {
2136 private:
2137         LDKRetryAttempts self;
2138 public:
2139         RetryAttempts(const RetryAttempts&) = delete;
2140         RetryAttempts(RetryAttempts&& o) : self(o.self) { memset(&o, 0, sizeof(RetryAttempts)); }
2141         RetryAttempts(LDKRetryAttempts&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetryAttempts)); }
2142         operator LDKRetryAttempts() && { LDKRetryAttempts res = self; memset(&self, 0, sizeof(LDKRetryAttempts)); return res; }
2143         ~RetryAttempts() { RetryAttempts_free(self); }
2144         RetryAttempts& operator=(RetryAttempts&& o) { RetryAttempts_free(self); self = o.self; memset(&o, 0, sizeof(RetryAttempts)); return *this; }
2145         LDKRetryAttempts* operator &() { return &self; }
2146         LDKRetryAttempts* operator ->() { return &self; }
2147         const LDKRetryAttempts* operator &() const { return &self; }
2148         const LDKRetryAttempts* operator ->() const { return &self; }
2149 };
2150 class PaymentError {
2151 private:
2152         LDKPaymentError self;
2153 public:
2154         PaymentError(const PaymentError&) = delete;
2155         PaymentError(PaymentError&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentError)); }
2156         PaymentError(LDKPaymentError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentError)); }
2157         operator LDKPaymentError() && { LDKPaymentError res = self; memset(&self, 0, sizeof(LDKPaymentError)); return res; }
2158         ~PaymentError() { PaymentError_free(self); }
2159         PaymentError& operator=(PaymentError&& o) { PaymentError_free(self); self = o.self; memset(&o, 0, sizeof(PaymentError)); return *this; }
2160         LDKPaymentError* operator &() { return &self; }
2161         LDKPaymentError* operator ->() { return &self; }
2162         const LDKPaymentError* operator &() const { return &self; }
2163         const LDKPaymentError* operator ->() const { return &self; }
2164 };
2165 class Invoice {
2166 private:
2167         LDKInvoice self;
2168 public:
2169         Invoice(const Invoice&) = delete;
2170         Invoice(Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Invoice)); }
2171         Invoice(LDKInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoice)); }
2172         operator LDKInvoice() && { LDKInvoice res = self; memset(&self, 0, sizeof(LDKInvoice)); return res; }
2173         ~Invoice() { Invoice_free(self); }
2174         Invoice& operator=(Invoice&& o) { Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Invoice)); return *this; }
2175         LDKInvoice* operator &() { return &self; }
2176         LDKInvoice* operator ->() { return &self; }
2177         const LDKInvoice* operator &() const { return &self; }
2178         const LDKInvoice* operator ->() const { return &self; }
2179 };
2180 class SignedRawInvoice {
2181 private:
2182         LDKSignedRawInvoice self;
2183 public:
2184         SignedRawInvoice(const SignedRawInvoice&) = delete;
2185         SignedRawInvoice(SignedRawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawInvoice)); }
2186         SignedRawInvoice(LDKSignedRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawInvoice)); }
2187         operator LDKSignedRawInvoice() && { LDKSignedRawInvoice res = self; memset(&self, 0, sizeof(LDKSignedRawInvoice)); return res; }
2188         ~SignedRawInvoice() { SignedRawInvoice_free(self); }
2189         SignedRawInvoice& operator=(SignedRawInvoice&& o) { SignedRawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawInvoice)); return *this; }
2190         LDKSignedRawInvoice* operator &() { return &self; }
2191         LDKSignedRawInvoice* operator ->() { return &self; }
2192         const LDKSignedRawInvoice* operator &() const { return &self; }
2193         const LDKSignedRawInvoice* operator ->() const { return &self; }
2194 };
2195 class RawInvoice {
2196 private:
2197         LDKRawInvoice self;
2198 public:
2199         RawInvoice(const RawInvoice&) = delete;
2200         RawInvoice(RawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawInvoice)); }
2201         RawInvoice(LDKRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawInvoice)); }
2202         operator LDKRawInvoice() && { LDKRawInvoice res = self; memset(&self, 0, sizeof(LDKRawInvoice)); return res; }
2203         ~RawInvoice() { RawInvoice_free(self); }
2204         RawInvoice& operator=(RawInvoice&& o) { RawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(RawInvoice)); return *this; }
2205         LDKRawInvoice* operator &() { return &self; }
2206         LDKRawInvoice* operator ->() { return &self; }
2207         const LDKRawInvoice* operator &() const { return &self; }
2208         const LDKRawInvoice* operator ->() const { return &self; }
2209 };
2210 class RawDataPart {
2211 private:
2212         LDKRawDataPart self;
2213 public:
2214         RawDataPart(const RawDataPart&) = delete;
2215         RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
2216         RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
2217         operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
2218         ~RawDataPart() { RawDataPart_free(self); }
2219         RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
2220         LDKRawDataPart* operator &() { return &self; }
2221         LDKRawDataPart* operator ->() { return &self; }
2222         const LDKRawDataPart* operator &() const { return &self; }
2223         const LDKRawDataPart* operator ->() const { return &self; }
2224 };
2225 class PositiveTimestamp {
2226 private:
2227         LDKPositiveTimestamp self;
2228 public:
2229         PositiveTimestamp(const PositiveTimestamp&) = delete;
2230         PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
2231         PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
2232         operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
2233         ~PositiveTimestamp() { PositiveTimestamp_free(self); }
2234         PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
2235         LDKPositiveTimestamp* operator &() { return &self; }
2236         LDKPositiveTimestamp* operator ->() { return &self; }
2237         const LDKPositiveTimestamp* operator &() const { return &self; }
2238         const LDKPositiveTimestamp* operator ->() const { return &self; }
2239 };
2240 class SiPrefix {
2241 private:
2242         LDKSiPrefix self;
2243 public:
2244         SiPrefix(const SiPrefix&) = delete;
2245         SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
2246         SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
2247         operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
2248         SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
2249         LDKSiPrefix* operator &() { return &self; }
2250         LDKSiPrefix* operator ->() { return &self; }
2251         const LDKSiPrefix* operator &() const { return &self; }
2252         const LDKSiPrefix* operator ->() const { return &self; }
2253 };
2254 class Currency {
2255 private:
2256         LDKCurrency self;
2257 public:
2258         Currency(const Currency&) = delete;
2259         Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
2260         Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
2261         operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
2262         Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
2263         LDKCurrency* operator &() { return &self; }
2264         LDKCurrency* operator ->() { return &self; }
2265         const LDKCurrency* operator &() const { return &self; }
2266         const LDKCurrency* operator ->() const { return &self; }
2267 };
2268 class Sha256 {
2269 private:
2270         LDKSha256 self;
2271 public:
2272         Sha256(const Sha256&) = delete;
2273         Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
2274         Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
2275         operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
2276         ~Sha256() { Sha256_free(self); }
2277         Sha256& operator=(Sha256&& o) { Sha256_free(self); self = o.self; memset(&o, 0, sizeof(Sha256)); return *this; }
2278         LDKSha256* operator &() { return &self; }
2279         LDKSha256* operator ->() { return &self; }
2280         const LDKSha256* operator &() const { return &self; }
2281         const LDKSha256* operator ->() const { return &self; }
2282 };
2283 class Description {
2284 private:
2285         LDKDescription self;
2286 public:
2287         Description(const Description&) = delete;
2288         Description(Description&& o) : self(o.self) { memset(&o, 0, sizeof(Description)); }
2289         Description(LDKDescription&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDescription)); }
2290         operator LDKDescription() && { LDKDescription res = self; memset(&self, 0, sizeof(LDKDescription)); return res; }
2291         ~Description() { Description_free(self); }
2292         Description& operator=(Description&& o) { Description_free(self); self = o.self; memset(&o, 0, sizeof(Description)); return *this; }
2293         LDKDescription* operator &() { return &self; }
2294         LDKDescription* operator ->() { return &self; }
2295         const LDKDescription* operator &() const { return &self; }
2296         const LDKDescription* operator ->() const { return &self; }
2297 };
2298 class PayeePubKey {
2299 private:
2300         LDKPayeePubKey self;
2301 public:
2302         PayeePubKey(const PayeePubKey&) = delete;
2303         PayeePubKey(PayeePubKey&& o) : self(o.self) { memset(&o, 0, sizeof(PayeePubKey)); }
2304         PayeePubKey(LDKPayeePubKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayeePubKey)); }
2305         operator LDKPayeePubKey() && { LDKPayeePubKey res = self; memset(&self, 0, sizeof(LDKPayeePubKey)); return res; }
2306         ~PayeePubKey() { PayeePubKey_free(self); }
2307         PayeePubKey& operator=(PayeePubKey&& o) { PayeePubKey_free(self); self = o.self; memset(&o, 0, sizeof(PayeePubKey)); return *this; }
2308         LDKPayeePubKey* operator &() { return &self; }
2309         LDKPayeePubKey* operator ->() { return &self; }
2310         const LDKPayeePubKey* operator &() const { return &self; }
2311         const LDKPayeePubKey* operator ->() const { return &self; }
2312 };
2313 class ExpiryTime {
2314 private:
2315         LDKExpiryTime self;
2316 public:
2317         ExpiryTime(const ExpiryTime&) = delete;
2318         ExpiryTime(ExpiryTime&& o) : self(o.self) { memset(&o, 0, sizeof(ExpiryTime)); }
2319         ExpiryTime(LDKExpiryTime&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpiryTime)); }
2320         operator LDKExpiryTime() && { LDKExpiryTime res = self; memset(&self, 0, sizeof(LDKExpiryTime)); return res; }
2321         ~ExpiryTime() { ExpiryTime_free(self); }
2322         ExpiryTime& operator=(ExpiryTime&& o) { ExpiryTime_free(self); self = o.self; memset(&o, 0, sizeof(ExpiryTime)); return *this; }
2323         LDKExpiryTime* operator &() { return &self; }
2324         LDKExpiryTime* operator ->() { return &self; }
2325         const LDKExpiryTime* operator &() const { return &self; }
2326         const LDKExpiryTime* operator ->() const { return &self; }
2327 };
2328 class MinFinalCltvExpiry {
2329 private:
2330         LDKMinFinalCltvExpiry self;
2331 public:
2332         MinFinalCltvExpiry(const MinFinalCltvExpiry&) = delete;
2333         MinFinalCltvExpiry(MinFinalCltvExpiry&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiry)); }
2334         MinFinalCltvExpiry(LDKMinFinalCltvExpiry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiry)); }
2335         operator LDKMinFinalCltvExpiry() && { LDKMinFinalCltvExpiry res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiry)); return res; }
2336         ~MinFinalCltvExpiry() { MinFinalCltvExpiry_free(self); }
2337         MinFinalCltvExpiry& operator=(MinFinalCltvExpiry&& o) { MinFinalCltvExpiry_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiry)); return *this; }
2338         LDKMinFinalCltvExpiry* operator &() { return &self; }
2339         LDKMinFinalCltvExpiry* operator ->() { return &self; }
2340         const LDKMinFinalCltvExpiry* operator &() const { return &self; }
2341         const LDKMinFinalCltvExpiry* operator ->() const { return &self; }
2342 };
2343 class Fallback {
2344 private:
2345         LDKFallback self;
2346 public:
2347         Fallback(const Fallback&) = delete;
2348         Fallback(Fallback&& o) : self(o.self) { memset(&o, 0, sizeof(Fallback)); }
2349         Fallback(LDKFallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFallback)); }
2350         operator LDKFallback() && { LDKFallback res = self; memset(&self, 0, sizeof(LDKFallback)); return res; }
2351         ~Fallback() { Fallback_free(self); }
2352         Fallback& operator=(Fallback&& o) { Fallback_free(self); self = o.self; memset(&o, 0, sizeof(Fallback)); return *this; }
2353         LDKFallback* operator &() { return &self; }
2354         LDKFallback* operator ->() { return &self; }
2355         const LDKFallback* operator &() const { return &self; }
2356         const LDKFallback* operator ->() const { return &self; }
2357 };
2358 class InvoiceSignature {
2359 private:
2360         LDKInvoiceSignature self;
2361 public:
2362         InvoiceSignature(const InvoiceSignature&) = delete;
2363         InvoiceSignature(InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceSignature)); }
2364         InvoiceSignature(LDKInvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceSignature)); }
2365         operator LDKInvoiceSignature() && { LDKInvoiceSignature res = self; memset(&self, 0, sizeof(LDKInvoiceSignature)); return res; }
2366         ~InvoiceSignature() { InvoiceSignature_free(self); }
2367         InvoiceSignature& operator=(InvoiceSignature&& o) { InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceSignature)); return *this; }
2368         LDKInvoiceSignature* operator &() { return &self; }
2369         LDKInvoiceSignature* operator ->() { return &self; }
2370         const LDKInvoiceSignature* operator &() const { return &self; }
2371         const LDKInvoiceSignature* operator ->() const { return &self; }
2372 };
2373 class PrivateRoute {
2374 private:
2375         LDKPrivateRoute self;
2376 public:
2377         PrivateRoute(const PrivateRoute&) = delete;
2378         PrivateRoute(PrivateRoute&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateRoute)); }
2379         PrivateRoute(LDKPrivateRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateRoute)); }
2380         operator LDKPrivateRoute() && { LDKPrivateRoute res = self; memset(&self, 0, sizeof(LDKPrivateRoute)); return res; }
2381         ~PrivateRoute() { PrivateRoute_free(self); }
2382         PrivateRoute& operator=(PrivateRoute&& o) { PrivateRoute_free(self); self = o.self; memset(&o, 0, sizeof(PrivateRoute)); return *this; }
2383         LDKPrivateRoute* operator &() { return &self; }
2384         LDKPrivateRoute* operator ->() { return &self; }
2385         const LDKPrivateRoute* operator &() const { return &self; }
2386         const LDKPrivateRoute* operator ->() const { return &self; }
2387 };
2388 class CreationError {
2389 private:
2390         LDKCreationError self;
2391 public:
2392         CreationError(const CreationError&) = delete;
2393         CreationError(CreationError&& o) : self(o.self) { memset(&o, 0, sizeof(CreationError)); }
2394         CreationError(LDKCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCreationError)); }
2395         operator LDKCreationError() && { LDKCreationError res = self; memset(&self, 0, sizeof(LDKCreationError)); return res; }
2396         CreationError& operator=(CreationError&& o) { self = o.self; memset(&o, 0, sizeof(CreationError)); return *this; }
2397         LDKCreationError* operator &() { return &self; }
2398         LDKCreationError* operator ->() { return &self; }
2399         const LDKCreationError* operator &() const { return &self; }
2400         const LDKCreationError* operator ->() const { return &self; }
2401 };
2402 class SemanticError {
2403 private:
2404         LDKSemanticError self;
2405 public:
2406         SemanticError(const SemanticError&) = delete;
2407         SemanticError(SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(SemanticError)); }
2408         SemanticError(LDKSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSemanticError)); }
2409         operator LDKSemanticError() && { LDKSemanticError res = self; memset(&self, 0, sizeof(LDKSemanticError)); return res; }
2410         SemanticError& operator=(SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(SemanticError)); return *this; }
2411         LDKSemanticError* operator &() { return &self; }
2412         LDKSemanticError* operator ->() { return &self; }
2413         const LDKSemanticError* operator &() const { return &self; }
2414         const LDKSemanticError* operator ->() const { return &self; }
2415 };
2416 class SignOrCreationError {
2417 private:
2418         LDKSignOrCreationError self;
2419 public:
2420         SignOrCreationError(const SignOrCreationError&) = delete;
2421         SignOrCreationError(SignOrCreationError&& o) : self(o.self) { memset(&o, 0, sizeof(SignOrCreationError)); }
2422         SignOrCreationError(LDKSignOrCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignOrCreationError)); }
2423         operator LDKSignOrCreationError() && { LDKSignOrCreationError res = self; memset(&self, 0, sizeof(LDKSignOrCreationError)); return res; }
2424         ~SignOrCreationError() { SignOrCreationError_free(self); }
2425         SignOrCreationError& operator=(SignOrCreationError&& o) { SignOrCreationError_free(self); self = o.self; memset(&o, 0, sizeof(SignOrCreationError)); return *this; }
2426         LDKSignOrCreationError* operator &() { return &self; }
2427         LDKSignOrCreationError* operator ->() { return &self; }
2428         const LDKSignOrCreationError* operator &() const { return &self; }
2429         const LDKSignOrCreationError* operator ->() const { return &self; }
2430 };
2431 class ChannelMonitorUpdate {
2432 private:
2433         LDKChannelMonitorUpdate self;
2434 public:
2435         ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
2436         ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
2437         ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
2438         operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
2439         ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
2440         ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
2441         LDKChannelMonitorUpdate* operator &() { return &self; }
2442         LDKChannelMonitorUpdate* operator ->() { return &self; }
2443         const LDKChannelMonitorUpdate* operator &() const { return &self; }
2444         const LDKChannelMonitorUpdate* operator ->() const { return &self; }
2445 };
2446 class MonitorEvent {
2447 private:
2448         LDKMonitorEvent self;
2449 public:
2450         MonitorEvent(const MonitorEvent&) = delete;
2451         MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
2452         MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
2453         operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
2454         ~MonitorEvent() { MonitorEvent_free(self); }
2455         MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
2456         LDKMonitorEvent* operator &() { return &self; }
2457         LDKMonitorEvent* operator ->() { return &self; }
2458         const LDKMonitorEvent* operator &() const { return &self; }
2459         const LDKMonitorEvent* operator ->() const { return &self; }
2460 };
2461 class HTLCUpdate {
2462 private:
2463         LDKHTLCUpdate self;
2464 public:
2465         HTLCUpdate(const HTLCUpdate&) = delete;
2466         HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
2467         HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
2468         operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
2469         ~HTLCUpdate() { HTLCUpdate_free(self); }
2470         HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
2471         LDKHTLCUpdate* operator &() { return &self; }
2472         LDKHTLCUpdate* operator ->() { return &self; }
2473         const LDKHTLCUpdate* operator &() const { return &self; }
2474         const LDKHTLCUpdate* operator ->() const { return &self; }
2475 };
2476 class Balance {
2477 private:
2478         LDKBalance self;
2479 public:
2480         Balance(const Balance&) = delete;
2481         Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
2482         Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
2483         operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
2484         ~Balance() { Balance_free(self); }
2485         Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
2486         LDKBalance* operator &() { return &self; }
2487         LDKBalance* operator ->() { return &self; }
2488         const LDKBalance* operator &() const { return &self; }
2489         const LDKBalance* operator ->() const { return &self; }
2490 };
2491 class ChannelMonitor {
2492 private:
2493         LDKChannelMonitor self;
2494 public:
2495         ChannelMonitor(const ChannelMonitor&) = delete;
2496         ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
2497         ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
2498         operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
2499         ~ChannelMonitor() { ChannelMonitor_free(self); }
2500         ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
2501         LDKChannelMonitor* operator &() { return &self; }
2502         LDKChannelMonitor* operator ->() { return &self; }
2503         const LDKChannelMonitor* operator &() const { return &self; }
2504         const LDKChannelMonitor* operator ->() const { return &self; }
2505 };
2506 class CustomMessageHandler {
2507 private:
2508         LDKCustomMessageHandler self;
2509 public:
2510         CustomMessageHandler(const CustomMessageHandler&) = delete;
2511         CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
2512         CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
2513         operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
2514         ~CustomMessageHandler() { CustomMessageHandler_free(self); }
2515         CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
2516         LDKCustomMessageHandler* operator &() { return &self; }
2517         LDKCustomMessageHandler* operator ->() { return &self; }
2518         const LDKCustomMessageHandler* operator &() const { return &self; }
2519         const LDKCustomMessageHandler* operator ->() const { return &self; }
2520         /**
2521          *  Called with the message type that was received and the buffer to be read.
2522          *  Can return a `MessageHandlingError` if the message could not be handled.
2523          */
2524         inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
2525         /**
2526          *  Gets the list of pending messages which were generated by the custom message
2527          *  handler, clearing the list in the process. The first tuple element must
2528          *  correspond to the intended recipients node ids. If no connection to one of the
2529          *  specified node does not exist, the message is simply not sent to it.
2530          */
2531         inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
2532 };
2533 class IgnoringMessageHandler {
2534 private:
2535         LDKIgnoringMessageHandler self;
2536 public:
2537         IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
2538         IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
2539         IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
2540         operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
2541         ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
2542         IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
2543         LDKIgnoringMessageHandler* operator &() { return &self; }
2544         LDKIgnoringMessageHandler* operator ->() { return &self; }
2545         const LDKIgnoringMessageHandler* operator &() const { return &self; }
2546         const LDKIgnoringMessageHandler* operator ->() const { return &self; }
2547 };
2548 class ErroringMessageHandler {
2549 private:
2550         LDKErroringMessageHandler self;
2551 public:
2552         ErroringMessageHandler(const ErroringMessageHandler&) = delete;
2553         ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
2554         ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
2555         operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
2556         ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
2557         ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
2558         LDKErroringMessageHandler* operator &() { return &self; }
2559         LDKErroringMessageHandler* operator ->() { return &self; }
2560         const LDKErroringMessageHandler* operator &() const { return &self; }
2561         const LDKErroringMessageHandler* operator ->() const { return &self; }
2562 };
2563 class MessageHandler {
2564 private:
2565         LDKMessageHandler self;
2566 public:
2567         MessageHandler(const MessageHandler&) = delete;
2568         MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
2569         MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
2570         operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
2571         ~MessageHandler() { MessageHandler_free(self); }
2572         MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
2573         LDKMessageHandler* operator &() { return &self; }
2574         LDKMessageHandler* operator ->() { return &self; }
2575         const LDKMessageHandler* operator &() const { return &self; }
2576         const LDKMessageHandler* operator ->() const { return &self; }
2577 };
2578 class SocketDescriptor {
2579 private:
2580         LDKSocketDescriptor self;
2581 public:
2582         SocketDescriptor(const SocketDescriptor&) = delete;
2583         SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
2584         SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
2585         operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
2586         ~SocketDescriptor() { SocketDescriptor_free(self); }
2587         SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
2588         LDKSocketDescriptor* operator &() { return &self; }
2589         LDKSocketDescriptor* operator ->() { return &self; }
2590         const LDKSocketDescriptor* operator &() const { return &self; }
2591         const LDKSocketDescriptor* operator ->() const { return &self; }
2592         /**
2593          *  Attempts to send some data from the given slice to the peer.
2594          *
2595          *  Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
2596          *  Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
2597          *  called and further write attempts may occur until that time.
2598          *
2599          *  If the returned size is smaller than `data.len()`, a
2600          *  [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
2601          *  written. Additionally, until a `send_data` event completes fully, no further
2602          *  [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
2603          *  prevent denial-of-service issues, you should not read or buffer any data from the socket
2604          *  until then.
2605          *
2606          *  If a [`PeerManager::read_event`] call on this descriptor had previously returned true
2607          *  (indicating that read events should be paused to prevent DoS in the send buffer),
2608          *  `resume_read` may be set indicating that read events on this descriptor should resume. A
2609          *  `resume_read` of false carries no meaning, and should not cause any action.
2610          */
2611         inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
2612         /**
2613          *  Disconnect the socket pointed to by this SocketDescriptor.
2614          *
2615          *  You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
2616          *  call (doing so is a noop).
2617          */
2618         inline void disconnect_socket();
2619         /** Checks if two objects are equal given this object's this_arg pointer and another object. */
2620         inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
2621         /**
2622          * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
2623          * This is used, for example, for inclusion of this object in a hash map.
2624          */
2625         inline uint64_t hash();
2626 };
2627 class PeerHandleError {
2628 private:
2629         LDKPeerHandleError self;
2630 public:
2631         PeerHandleError(const PeerHandleError&) = delete;
2632         PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
2633         PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
2634         operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
2635         ~PeerHandleError() { PeerHandleError_free(self); }
2636         PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
2637         LDKPeerHandleError* operator &() { return &self; }
2638         LDKPeerHandleError* operator ->() { return &self; }
2639         const LDKPeerHandleError* operator &() const { return &self; }
2640         const LDKPeerHandleError* operator ->() const { return &self; }
2641 };
2642 class PeerManager {
2643 private:
2644         LDKPeerManager self;
2645 public:
2646         PeerManager(const PeerManager&) = delete;
2647         PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
2648         PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
2649         operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
2650         ~PeerManager() { PeerManager_free(self); }
2651         PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
2652         LDKPeerManager* operator &() { return &self; }
2653         LDKPeerManager* operator ->() { return &self; }
2654         const LDKPeerManager* operator &() const { return &self; }
2655         const LDKPeerManager* operator ->() const { return &self; }
2656 };
2657 class NodeId {
2658 private:
2659         LDKNodeId self;
2660 public:
2661         NodeId(const NodeId&) = delete;
2662         NodeId(NodeId&& o) : self(o.self) { memset(&o, 0, sizeof(NodeId)); }
2663         NodeId(LDKNodeId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeId)); }
2664         operator LDKNodeId() && { LDKNodeId res = self; memset(&self, 0, sizeof(LDKNodeId)); return res; }
2665         ~NodeId() { NodeId_free(self); }
2666         NodeId& operator=(NodeId&& o) { NodeId_free(self); self = o.self; memset(&o, 0, sizeof(NodeId)); return *this; }
2667         LDKNodeId* operator &() { return &self; }
2668         LDKNodeId* operator ->() { return &self; }
2669         const LDKNodeId* operator &() const { return &self; }
2670         const LDKNodeId* operator ->() const { return &self; }
2671 };
2672 class NetworkGraph {
2673 private:
2674         LDKNetworkGraph self;
2675 public:
2676         NetworkGraph(const NetworkGraph&) = delete;
2677         NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
2678         NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
2679         operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
2680         ~NetworkGraph() { NetworkGraph_free(self); }
2681         NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
2682         LDKNetworkGraph* operator &() { return &self; }
2683         LDKNetworkGraph* operator ->() { return &self; }
2684         const LDKNetworkGraph* operator &() const { return &self; }
2685         const LDKNetworkGraph* operator ->() const { return &self; }
2686 };
2687 class ReadOnlyNetworkGraph {
2688 private:
2689         LDKReadOnlyNetworkGraph self;
2690 public:
2691         ReadOnlyNetworkGraph(const ReadOnlyNetworkGraph&) = delete;
2692         ReadOnlyNetworkGraph(ReadOnlyNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); }
2693         ReadOnlyNetworkGraph(LDKReadOnlyNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReadOnlyNetworkGraph)); }
2694         operator LDKReadOnlyNetworkGraph() && { LDKReadOnlyNetworkGraph res = self; memset(&self, 0, sizeof(LDKReadOnlyNetworkGraph)); return res; }
2695         ~ReadOnlyNetworkGraph() { ReadOnlyNetworkGraph_free(self); }
2696         ReadOnlyNetworkGraph& operator=(ReadOnlyNetworkGraph&& o) { ReadOnlyNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); return *this; }
2697         LDKReadOnlyNetworkGraph* operator &() { return &self; }
2698         LDKReadOnlyNetworkGraph* operator ->() { return &self; }
2699         const LDKReadOnlyNetworkGraph* operator &() const { return &self; }
2700         const LDKReadOnlyNetworkGraph* operator ->() const { return &self; }
2701 };
2702 class NetworkUpdate {
2703 private:
2704         LDKNetworkUpdate self;
2705 public:
2706         NetworkUpdate(const NetworkUpdate&) = delete;
2707         NetworkUpdate(NetworkUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkUpdate)); }
2708         NetworkUpdate(LDKNetworkUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkUpdate)); }
2709         operator LDKNetworkUpdate() && { LDKNetworkUpdate res = self; memset(&self, 0, sizeof(LDKNetworkUpdate)); return res; }
2710         ~NetworkUpdate() { NetworkUpdate_free(self); }
2711         NetworkUpdate& operator=(NetworkUpdate&& o) { NetworkUpdate_free(self); self = o.self; memset(&o, 0, sizeof(NetworkUpdate)); return *this; }
2712         LDKNetworkUpdate* operator &() { return &self; }
2713         LDKNetworkUpdate* operator ->() { return &self; }
2714         const LDKNetworkUpdate* operator &() const { return &self; }
2715         const LDKNetworkUpdate* operator ->() const { return &self; }
2716 };
2717 class NetGraphMsgHandler {
2718 private:
2719         LDKNetGraphMsgHandler self;
2720 public:
2721         NetGraphMsgHandler(const NetGraphMsgHandler&) = delete;
2722         NetGraphMsgHandler(NetGraphMsgHandler&& o) : self(o.self) { memset(&o, 0, sizeof(NetGraphMsgHandler)); }
2723         NetGraphMsgHandler(LDKNetGraphMsgHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetGraphMsgHandler)); }
2724         operator LDKNetGraphMsgHandler() && { LDKNetGraphMsgHandler res = self; memset(&self, 0, sizeof(LDKNetGraphMsgHandler)); return res; }
2725         ~NetGraphMsgHandler() { NetGraphMsgHandler_free(self); }
2726         NetGraphMsgHandler& operator=(NetGraphMsgHandler&& o) { NetGraphMsgHandler_free(self); self = o.self; memset(&o, 0, sizeof(NetGraphMsgHandler)); return *this; }
2727         LDKNetGraphMsgHandler* operator &() { return &self; }
2728         LDKNetGraphMsgHandler* operator ->() { return &self; }
2729         const LDKNetGraphMsgHandler* operator &() const { return &self; }
2730         const LDKNetGraphMsgHandler* operator ->() const { return &self; }
2731 };
2732 class ChannelUpdateInfo {
2733 private:
2734         LDKChannelUpdateInfo self;
2735 public:
2736         ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
2737         ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
2738         ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
2739         operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
2740         ~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
2741         ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
2742         LDKChannelUpdateInfo* operator &() { return &self; }
2743         LDKChannelUpdateInfo* operator ->() { return &self; }
2744         const LDKChannelUpdateInfo* operator &() const { return &self; }
2745         const LDKChannelUpdateInfo* operator ->() const { return &self; }
2746 };
2747 class ChannelInfo {
2748 private:
2749         LDKChannelInfo self;
2750 public:
2751         ChannelInfo(const ChannelInfo&) = delete;
2752         ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
2753         ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
2754         operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
2755         ~ChannelInfo() { ChannelInfo_free(self); }
2756         ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
2757         LDKChannelInfo* operator &() { return &self; }
2758         LDKChannelInfo* operator ->() { return &self; }
2759         const LDKChannelInfo* operator &() const { return &self; }
2760         const LDKChannelInfo* operator ->() const { return &self; }
2761 };
2762 class DirectedChannelInfo {
2763 private:
2764         LDKDirectedChannelInfo self;
2765 public:
2766         DirectedChannelInfo(const DirectedChannelInfo&) = delete;
2767         DirectedChannelInfo(DirectedChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelInfo)); }
2768         DirectedChannelInfo(LDKDirectedChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelInfo)); }
2769         operator LDKDirectedChannelInfo() && { LDKDirectedChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectedChannelInfo)); return res; }
2770         ~DirectedChannelInfo() { DirectedChannelInfo_free(self); }
2771         DirectedChannelInfo& operator=(DirectedChannelInfo&& o) { DirectedChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelInfo)); return *this; }
2772         LDKDirectedChannelInfo* operator &() { return &self; }
2773         LDKDirectedChannelInfo* operator ->() { return &self; }
2774         const LDKDirectedChannelInfo* operator &() const { return &self; }
2775         const LDKDirectedChannelInfo* operator ->() const { return &self; }
2776 };
2777 class EffectiveCapacity {
2778 private:
2779         LDKEffectiveCapacity self;
2780 public:
2781         EffectiveCapacity(const EffectiveCapacity&) = delete;
2782         EffectiveCapacity(EffectiveCapacity&& o) : self(o.self) { memset(&o, 0, sizeof(EffectiveCapacity)); }
2783         EffectiveCapacity(LDKEffectiveCapacity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEffectiveCapacity)); }
2784         operator LDKEffectiveCapacity() && { LDKEffectiveCapacity res = self; memset(&self, 0, sizeof(LDKEffectiveCapacity)); return res; }
2785         ~EffectiveCapacity() { EffectiveCapacity_free(self); }
2786         EffectiveCapacity& operator=(EffectiveCapacity&& o) { EffectiveCapacity_free(self); self = o.self; memset(&o, 0, sizeof(EffectiveCapacity)); return *this; }
2787         LDKEffectiveCapacity* operator &() { return &self; }
2788         LDKEffectiveCapacity* operator ->() { return &self; }
2789         const LDKEffectiveCapacity* operator &() const { return &self; }
2790         const LDKEffectiveCapacity* operator ->() const { return &self; }
2791 };
2792 class RoutingFees {
2793 private:
2794         LDKRoutingFees self;
2795 public:
2796         RoutingFees(const RoutingFees&) = delete;
2797         RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
2798         RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
2799         operator LDKRoutingFees() && { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
2800         ~RoutingFees() { RoutingFees_free(self); }
2801         RoutingFees& operator=(RoutingFees&& o) { RoutingFees_free(self); self = o.self; memset(&o, 0, sizeof(RoutingFees)); return *this; }
2802         LDKRoutingFees* operator &() { return &self; }
2803         LDKRoutingFees* operator ->() { return &self; }
2804         const LDKRoutingFees* operator &() const { return &self; }
2805         const LDKRoutingFees* operator ->() const { return &self; }
2806 };
2807 class NodeAnnouncementInfo {
2808 private:
2809         LDKNodeAnnouncementInfo self;
2810 public:
2811         NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
2812         NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
2813         NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
2814         operator LDKNodeAnnouncementInfo() && { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
2815         ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
2816         NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
2817         LDKNodeAnnouncementInfo* operator &() { return &self; }
2818         LDKNodeAnnouncementInfo* operator ->() { return &self; }
2819         const LDKNodeAnnouncementInfo* operator &() const { return &self; }
2820         const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
2821 };
2822 class NodeInfo {
2823 private:
2824         LDKNodeInfo self;
2825 public:
2826         NodeInfo(const NodeInfo&) = delete;
2827         NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
2828         NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
2829         operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
2830         ~NodeInfo() { NodeInfo_free(self); }
2831         NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
2832         LDKNodeInfo* operator &() { return &self; }
2833         LDKNodeInfo* operator ->() { return &self; }
2834         const LDKNodeInfo* operator &() const { return &self; }
2835         const LDKNodeInfo* operator ->() const { return &self; }
2836 };
2837 class DecodeError {
2838 private:
2839         LDKDecodeError self;
2840 public:
2841         DecodeError(const DecodeError&) = delete;
2842         DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
2843         DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
2844         operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
2845         ~DecodeError() { DecodeError_free(self); }
2846         DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
2847         LDKDecodeError* operator &() { return &self; }
2848         LDKDecodeError* operator ->() { return &self; }
2849         const LDKDecodeError* operator &() const { return &self; }
2850         const LDKDecodeError* operator ->() const { return &self; }
2851 };
2852 class Init {
2853 private:
2854         LDKInit self;
2855 public:
2856         Init(const Init&) = delete;
2857         Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
2858         Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
2859         operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
2860         ~Init() { Init_free(self); }
2861         Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
2862         LDKInit* operator &() { return &self; }
2863         LDKInit* operator ->() { return &self; }
2864         const LDKInit* operator &() const { return &self; }
2865         const LDKInit* operator ->() const { return &self; }
2866 };
2867 class ErrorMessage {
2868 private:
2869         LDKErrorMessage self;
2870 public:
2871         ErrorMessage(const ErrorMessage&) = delete;
2872         ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
2873         ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
2874         operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
2875         ~ErrorMessage() { ErrorMessage_free(self); }
2876         ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
2877         LDKErrorMessage* operator &() { return &self; }
2878         LDKErrorMessage* operator ->() { return &self; }
2879         const LDKErrorMessage* operator &() const { return &self; }
2880         const LDKErrorMessage* operator ->() const { return &self; }
2881 };
2882 class WarningMessage {
2883 private:
2884         LDKWarningMessage self;
2885 public:
2886         WarningMessage(const WarningMessage&) = delete;
2887         WarningMessage(WarningMessage&& o) : self(o.self) { memset(&o, 0, sizeof(WarningMessage)); }
2888         WarningMessage(LDKWarningMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWarningMessage)); }
2889         operator LDKWarningMessage() && { LDKWarningMessage res = self; memset(&self, 0, sizeof(LDKWarningMessage)); return res; }
2890         ~WarningMessage() { WarningMessage_free(self); }
2891         WarningMessage& operator=(WarningMessage&& o) { WarningMessage_free(self); self = o.self; memset(&o, 0, sizeof(WarningMessage)); return *this; }
2892         LDKWarningMessage* operator &() { return &self; }
2893         LDKWarningMessage* operator ->() { return &self; }
2894         const LDKWarningMessage* operator &() const { return &self; }
2895         const LDKWarningMessage* operator ->() const { return &self; }
2896 };
2897 class Ping {
2898 private:
2899         LDKPing self;
2900 public:
2901         Ping(const Ping&) = delete;
2902         Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
2903         Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
2904         operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
2905         ~Ping() { Ping_free(self); }
2906         Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
2907         LDKPing* operator &() { return &self; }
2908         LDKPing* operator ->() { return &self; }
2909         const LDKPing* operator &() const { return &self; }
2910         const LDKPing* operator ->() const { return &self; }
2911 };
2912 class Pong {
2913 private:
2914         LDKPong self;
2915 public:
2916         Pong(const Pong&) = delete;
2917         Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
2918         Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
2919         operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
2920         ~Pong() { Pong_free(self); }
2921         Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
2922         LDKPong* operator &() { return &self; }
2923         LDKPong* operator ->() { return &self; }
2924         const LDKPong* operator &() const { return &self; }
2925         const LDKPong* operator ->() const { return &self; }
2926 };
2927 class OpenChannel {
2928 private:
2929         LDKOpenChannel self;
2930 public:
2931         OpenChannel(const OpenChannel&) = delete;
2932         OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
2933         OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
2934         operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
2935         ~OpenChannel() { OpenChannel_free(self); }
2936         OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
2937         LDKOpenChannel* operator &() { return &self; }
2938         LDKOpenChannel* operator ->() { return &self; }
2939         const LDKOpenChannel* operator &() const { return &self; }
2940         const LDKOpenChannel* operator ->() const { return &self; }
2941 };
2942 class AcceptChannel {
2943 private:
2944         LDKAcceptChannel self;
2945 public:
2946         AcceptChannel(const AcceptChannel&) = delete;
2947         AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
2948         AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
2949         operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
2950         ~AcceptChannel() { AcceptChannel_free(self); }
2951         AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
2952         LDKAcceptChannel* operator &() { return &self; }
2953         LDKAcceptChannel* operator ->() { return &self; }
2954         const LDKAcceptChannel* operator &() const { return &self; }
2955         const LDKAcceptChannel* operator ->() const { return &self; }
2956 };
2957 class FundingCreated {
2958 private:
2959         LDKFundingCreated self;
2960 public:
2961         FundingCreated(const FundingCreated&) = delete;
2962         FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
2963         FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
2964         operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
2965         ~FundingCreated() { FundingCreated_free(self); }
2966         FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
2967         LDKFundingCreated* operator &() { return &self; }
2968         LDKFundingCreated* operator ->() { return &self; }
2969         const LDKFundingCreated* operator &() const { return &self; }
2970         const LDKFundingCreated* operator ->() const { return &self; }
2971 };
2972 class FundingSigned {
2973 private:
2974         LDKFundingSigned self;
2975 public:
2976         FundingSigned(const FundingSigned&) = delete;
2977         FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
2978         FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
2979         operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
2980         ~FundingSigned() { FundingSigned_free(self); }
2981         FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
2982         LDKFundingSigned* operator &() { return &self; }
2983         LDKFundingSigned* operator ->() { return &self; }
2984         const LDKFundingSigned* operator &() const { return &self; }
2985         const LDKFundingSigned* operator ->() const { return &self; }
2986 };
2987 class FundingLocked {
2988 private:
2989         LDKFundingLocked self;
2990 public:
2991         FundingLocked(const FundingLocked&) = delete;
2992         FundingLocked(FundingLocked&& o) : self(o.self) { memset(&o, 0, sizeof(FundingLocked)); }
2993         FundingLocked(LDKFundingLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingLocked)); }
2994         operator LDKFundingLocked() && { LDKFundingLocked res = self; memset(&self, 0, sizeof(LDKFundingLocked)); return res; }
2995         ~FundingLocked() { FundingLocked_free(self); }
2996         FundingLocked& operator=(FundingLocked&& o) { FundingLocked_free(self); self = o.self; memset(&o, 0, sizeof(FundingLocked)); return *this; }
2997         LDKFundingLocked* operator &() { return &self; }
2998         LDKFundingLocked* operator ->() { return &self; }
2999         const LDKFundingLocked* operator &() const { return &self; }
3000         const LDKFundingLocked* operator ->() const { return &self; }
3001 };
3002 class Shutdown {
3003 private:
3004         LDKShutdown self;
3005 public:
3006         Shutdown(const Shutdown&) = delete;
3007         Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
3008         Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
3009         operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
3010         ~Shutdown() { Shutdown_free(self); }
3011         Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
3012         LDKShutdown* operator &() { return &self; }
3013         LDKShutdown* operator ->() { return &self; }
3014         const LDKShutdown* operator &() const { return &self; }
3015         const LDKShutdown* operator ->() const { return &self; }
3016 };
3017 class ClosingSignedFeeRange {
3018 private:
3019         LDKClosingSignedFeeRange self;
3020 public:
3021         ClosingSignedFeeRange(const ClosingSignedFeeRange&) = delete;
3022         ClosingSignedFeeRange(ClosingSignedFeeRange&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSignedFeeRange)); }
3023         ClosingSignedFeeRange(LDKClosingSignedFeeRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSignedFeeRange)); }
3024         operator LDKClosingSignedFeeRange() && { LDKClosingSignedFeeRange res = self; memset(&self, 0, sizeof(LDKClosingSignedFeeRange)); return res; }
3025         ~ClosingSignedFeeRange() { ClosingSignedFeeRange_free(self); }
3026         ClosingSignedFeeRange& operator=(ClosingSignedFeeRange&& o) { ClosingSignedFeeRange_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSignedFeeRange)); return *this; }
3027         LDKClosingSignedFeeRange* operator &() { return &self; }
3028         LDKClosingSignedFeeRange* operator ->() { return &self; }
3029         const LDKClosingSignedFeeRange* operator &() const { return &self; }
3030         const LDKClosingSignedFeeRange* operator ->() const { return &self; }
3031 };
3032 class ClosingSigned {
3033 private:
3034         LDKClosingSigned self;
3035 public:
3036         ClosingSigned(const ClosingSigned&) = delete;
3037         ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
3038         ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
3039         operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
3040         ~ClosingSigned() { ClosingSigned_free(self); }
3041         ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
3042         LDKClosingSigned* operator &() { return &self; }
3043         LDKClosingSigned* operator ->() { return &self; }
3044         const LDKClosingSigned* operator &() const { return &self; }
3045         const LDKClosingSigned* operator ->() const { return &self; }
3046 };
3047 class UpdateAddHTLC {
3048 private:
3049         LDKUpdateAddHTLC self;
3050 public:
3051         UpdateAddHTLC(const UpdateAddHTLC&) = delete;
3052         UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
3053         UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
3054         operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
3055         ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
3056         UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
3057         LDKUpdateAddHTLC* operator &() { return &self; }
3058         LDKUpdateAddHTLC* operator ->() { return &self; }
3059         const LDKUpdateAddHTLC* operator &() const { return &self; }
3060         const LDKUpdateAddHTLC* operator ->() const { return &self; }
3061 };
3062 class UpdateFulfillHTLC {
3063 private:
3064         LDKUpdateFulfillHTLC self;
3065 public:
3066         UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
3067         UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
3068         UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
3069         operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
3070         ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
3071         UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
3072         LDKUpdateFulfillHTLC* operator &() { return &self; }
3073         LDKUpdateFulfillHTLC* operator ->() { return &self; }
3074         const LDKUpdateFulfillHTLC* operator &() const { return &self; }
3075         const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
3076 };
3077 class UpdateFailHTLC {
3078 private:
3079         LDKUpdateFailHTLC self;
3080 public:
3081         UpdateFailHTLC(const UpdateFailHTLC&) = delete;
3082         UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
3083         UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
3084         operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
3085         ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
3086         UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
3087         LDKUpdateFailHTLC* operator &() { return &self; }
3088         LDKUpdateFailHTLC* operator ->() { return &self; }
3089         const LDKUpdateFailHTLC* operator &() const { return &self; }
3090         const LDKUpdateFailHTLC* operator ->() const { return &self; }
3091 };
3092 class UpdateFailMalformedHTLC {
3093 private:
3094         LDKUpdateFailMalformedHTLC self;
3095 public:
3096         UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
3097         UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
3098         UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
3099         operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
3100         ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
3101         UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
3102         LDKUpdateFailMalformedHTLC* operator &() { return &self; }
3103         LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
3104         const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
3105         const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
3106 };
3107 class CommitmentSigned {
3108 private:
3109         LDKCommitmentSigned self;
3110 public:
3111         CommitmentSigned(const CommitmentSigned&) = delete;
3112         CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
3113         CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
3114         operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
3115         ~CommitmentSigned() { CommitmentSigned_free(self); }
3116         CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
3117         LDKCommitmentSigned* operator &() { return &self; }
3118         LDKCommitmentSigned* operator ->() { return &self; }
3119         const LDKCommitmentSigned* operator &() const { return &self; }
3120         const LDKCommitmentSigned* operator ->() const { return &self; }
3121 };
3122 class RevokeAndACK {
3123 private:
3124         LDKRevokeAndACK self;
3125 public:
3126         RevokeAndACK(const RevokeAndACK&) = delete;
3127         RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
3128         RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
3129         operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
3130         ~RevokeAndACK() { RevokeAndACK_free(self); }
3131         RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
3132         LDKRevokeAndACK* operator &() { return &self; }
3133         LDKRevokeAndACK* operator ->() { return &self; }
3134         const LDKRevokeAndACK* operator &() const { return &self; }
3135         const LDKRevokeAndACK* operator ->() const { return &self; }
3136 };
3137 class UpdateFee {
3138 private:
3139         LDKUpdateFee self;
3140 public:
3141         UpdateFee(const UpdateFee&) = delete;
3142         UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
3143         UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
3144         operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
3145         ~UpdateFee() { UpdateFee_free(self); }
3146         UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
3147         LDKUpdateFee* operator &() { return &self; }
3148         LDKUpdateFee* operator ->() { return &self; }
3149         const LDKUpdateFee* operator &() const { return &self; }
3150         const LDKUpdateFee* operator ->() const { return &self; }
3151 };
3152 class DataLossProtect {
3153 private:
3154         LDKDataLossProtect self;
3155 public:
3156         DataLossProtect(const DataLossProtect&) = delete;
3157         DataLossProtect(DataLossProtect&& o) : self(o.self) { memset(&o, 0, sizeof(DataLossProtect)); }
3158         DataLossProtect(LDKDataLossProtect&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDataLossProtect)); }
3159         operator LDKDataLossProtect() && { LDKDataLossProtect res = self; memset(&self, 0, sizeof(LDKDataLossProtect)); return res; }
3160         ~DataLossProtect() { DataLossProtect_free(self); }
3161         DataLossProtect& operator=(DataLossProtect&& o) { DataLossProtect_free(self); self = o.self; memset(&o, 0, sizeof(DataLossProtect)); return *this; }
3162         LDKDataLossProtect* operator &() { return &self; }
3163         LDKDataLossProtect* operator ->() { return &self; }
3164         const LDKDataLossProtect* operator &() const { return &self; }
3165         const LDKDataLossProtect* operator ->() const { return &self; }
3166 };
3167 class ChannelReestablish {
3168 private:
3169         LDKChannelReestablish self;
3170 public:
3171         ChannelReestablish(const ChannelReestablish&) = delete;
3172         ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
3173         ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
3174         operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
3175         ~ChannelReestablish() { ChannelReestablish_free(self); }
3176         ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
3177         LDKChannelReestablish* operator &() { return &self; }
3178         LDKChannelReestablish* operator ->() { return &self; }
3179         const LDKChannelReestablish* operator &() const { return &self; }
3180         const LDKChannelReestablish* operator ->() const { return &self; }
3181 };
3182 class AnnouncementSignatures {
3183 private:
3184         LDKAnnouncementSignatures self;
3185 public:
3186         AnnouncementSignatures(const AnnouncementSignatures&) = delete;
3187         AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
3188         AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
3189         operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
3190         ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
3191         AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
3192         LDKAnnouncementSignatures* operator &() { return &self; }
3193         LDKAnnouncementSignatures* operator ->() { return &self; }
3194         const LDKAnnouncementSignatures* operator &() const { return &self; }
3195         const LDKAnnouncementSignatures* operator ->() const { return &self; }
3196 };
3197 class NetAddress {
3198 private:
3199         LDKNetAddress self;
3200 public:
3201         NetAddress(const NetAddress&) = delete;
3202         NetAddress(NetAddress&& o) : self(o.self) { memset(&o, 0, sizeof(NetAddress)); }
3203         NetAddress(LDKNetAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetAddress)); }
3204         operator LDKNetAddress() && { LDKNetAddress res = self; memset(&self, 0, sizeof(LDKNetAddress)); return res; }
3205         ~NetAddress() { NetAddress_free(self); }
3206         NetAddress& operator=(NetAddress&& o) { NetAddress_free(self); self = o.self; memset(&o, 0, sizeof(NetAddress)); return *this; }
3207         LDKNetAddress* operator &() { return &self; }
3208         LDKNetAddress* operator ->() { return &self; }
3209         const LDKNetAddress* operator &() const { return &self; }
3210         const LDKNetAddress* operator ->() const { return &self; }
3211 };
3212 class UnsignedNodeAnnouncement {
3213 private:
3214         LDKUnsignedNodeAnnouncement self;
3215 public:
3216         UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
3217         UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
3218         UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
3219         operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
3220         ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
3221         UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
3222         LDKUnsignedNodeAnnouncement* operator &() { return &self; }
3223         LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
3224         const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
3225         const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
3226 };
3227 class NodeAnnouncement {
3228 private:
3229         LDKNodeAnnouncement self;
3230 public:
3231         NodeAnnouncement(const NodeAnnouncement&) = delete;
3232         NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
3233         NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
3234         operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
3235         ~NodeAnnouncement() { NodeAnnouncement_free(self); }
3236         NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
3237         LDKNodeAnnouncement* operator &() { return &self; }
3238         LDKNodeAnnouncement* operator ->() { return &self; }
3239         const LDKNodeAnnouncement* operator &() const { return &self; }
3240         const LDKNodeAnnouncement* operator ->() const { return &self; }
3241 };
3242 class UnsignedChannelAnnouncement {
3243 private:
3244         LDKUnsignedChannelAnnouncement self;
3245 public:
3246         UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
3247         UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
3248         UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
3249         operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
3250         ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
3251         UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
3252         LDKUnsignedChannelAnnouncement* operator &() { return &self; }
3253         LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
3254         const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
3255         const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
3256 };
3257 class ChannelAnnouncement {
3258 private:
3259         LDKChannelAnnouncement self;
3260 public:
3261         ChannelAnnouncement(const ChannelAnnouncement&) = delete;
3262         ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
3263         ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
3264         operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
3265         ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
3266         ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
3267         LDKChannelAnnouncement* operator &() { return &self; }
3268         LDKChannelAnnouncement* operator ->() { return &self; }
3269         const LDKChannelAnnouncement* operator &() const { return &self; }
3270         const LDKChannelAnnouncement* operator ->() const { return &self; }
3271 };
3272 class UnsignedChannelUpdate {
3273 private:
3274         LDKUnsignedChannelUpdate self;
3275 public:
3276         UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
3277         UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
3278         UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
3279         operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
3280         ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
3281         UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
3282         LDKUnsignedChannelUpdate* operator &() { return &self; }
3283         LDKUnsignedChannelUpdate* operator ->() { return &self; }
3284         const LDKUnsignedChannelUpdate* operator &() const { return &self; }
3285         const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
3286 };
3287 class ChannelUpdate {
3288 private:
3289         LDKChannelUpdate self;
3290 public:
3291         ChannelUpdate(const ChannelUpdate&) = delete;
3292         ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
3293         ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
3294         operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
3295         ~ChannelUpdate() { ChannelUpdate_free(self); }
3296         ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
3297         LDKChannelUpdate* operator &() { return &self; }
3298         LDKChannelUpdate* operator ->() { return &self; }
3299         const LDKChannelUpdate* operator &() const { return &self; }
3300         const LDKChannelUpdate* operator ->() const { return &self; }
3301 };
3302 class QueryChannelRange {
3303 private:
3304         LDKQueryChannelRange self;
3305 public:
3306         QueryChannelRange(const QueryChannelRange&) = delete;
3307         QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
3308         QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
3309         operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
3310         ~QueryChannelRange() { QueryChannelRange_free(self); }
3311         QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
3312         LDKQueryChannelRange* operator &() { return &self; }
3313         LDKQueryChannelRange* operator ->() { return &self; }
3314         const LDKQueryChannelRange* operator &() const { return &self; }
3315         const LDKQueryChannelRange* operator ->() const { return &self; }
3316 };
3317 class ReplyChannelRange {
3318 private:
3319         LDKReplyChannelRange self;
3320 public:
3321         ReplyChannelRange(const ReplyChannelRange&) = delete;
3322         ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
3323         ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
3324         operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
3325         ~ReplyChannelRange() { ReplyChannelRange_free(self); }
3326         ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
3327         LDKReplyChannelRange* operator &() { return &self; }
3328         LDKReplyChannelRange* operator ->() { return &self; }
3329         const LDKReplyChannelRange* operator &() const { return &self; }
3330         const LDKReplyChannelRange* operator ->() const { return &self; }
3331 };
3332 class QueryShortChannelIds {
3333 private:
3334         LDKQueryShortChannelIds self;
3335 public:
3336         QueryShortChannelIds(const QueryShortChannelIds&) = delete;
3337         QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
3338         QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
3339         operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
3340         ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
3341         QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
3342         LDKQueryShortChannelIds* operator &() { return &self; }
3343         LDKQueryShortChannelIds* operator ->() { return &self; }
3344         const LDKQueryShortChannelIds* operator &() const { return &self; }
3345         const LDKQueryShortChannelIds* operator ->() const { return &self; }
3346 };
3347 class ReplyShortChannelIdsEnd {
3348 private:
3349         LDKReplyShortChannelIdsEnd self;
3350 public:
3351         ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
3352         ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
3353         ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
3354         operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
3355         ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
3356         ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
3357         LDKReplyShortChannelIdsEnd* operator &() { return &self; }
3358         LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
3359         const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
3360         const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
3361 };
3362 class GossipTimestampFilter {
3363 private:
3364         LDKGossipTimestampFilter self;
3365 public:
3366         GossipTimestampFilter(const GossipTimestampFilter&) = delete;
3367         GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
3368         GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
3369         operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
3370         ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
3371         GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
3372         LDKGossipTimestampFilter* operator &() { return &self; }
3373         LDKGossipTimestampFilter* operator ->() { return &self; }
3374         const LDKGossipTimestampFilter* operator &() const { return &self; }
3375         const LDKGossipTimestampFilter* operator ->() const { return &self; }
3376 };
3377 class ErrorAction {
3378 private:
3379         LDKErrorAction self;
3380 public:
3381         ErrorAction(const ErrorAction&) = delete;
3382         ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
3383         ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
3384         operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
3385         ~ErrorAction() { ErrorAction_free(self); }
3386         ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
3387         LDKErrorAction* operator &() { return &self; }
3388         LDKErrorAction* operator ->() { return &self; }
3389         const LDKErrorAction* operator &() const { return &self; }
3390         const LDKErrorAction* operator ->() const { return &self; }
3391 };
3392 class LightningError {
3393 private:
3394         LDKLightningError self;
3395 public:
3396         LightningError(const LightningError&) = delete;
3397         LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
3398         LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
3399         operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
3400         ~LightningError() { LightningError_free(self); }
3401         LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
3402         LDKLightningError* operator &() { return &self; }
3403         LDKLightningError* operator ->() { return &self; }
3404         const LDKLightningError* operator &() const { return &self; }
3405         const LDKLightningError* operator ->() const { return &self; }
3406 };
3407 class CommitmentUpdate {
3408 private:
3409         LDKCommitmentUpdate self;
3410 public:
3411         CommitmentUpdate(const CommitmentUpdate&) = delete;
3412         CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
3413         CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
3414         operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
3415         ~CommitmentUpdate() { CommitmentUpdate_free(self); }
3416         CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
3417         LDKCommitmentUpdate* operator &() { return &self; }
3418         LDKCommitmentUpdate* operator ->() { return &self; }
3419         const LDKCommitmentUpdate* operator &() const { return &self; }
3420         const LDKCommitmentUpdate* operator ->() const { return &self; }
3421 };
3422 class ChannelMessageHandler {
3423 private:
3424         LDKChannelMessageHandler self;
3425 public:
3426         ChannelMessageHandler(const ChannelMessageHandler&) = delete;
3427         ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
3428         ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
3429         operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
3430         ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
3431         ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
3432         LDKChannelMessageHandler* operator &() { return &self; }
3433         LDKChannelMessageHandler* operator ->() { return &self; }
3434         const LDKChannelMessageHandler* operator &() const { return &self; }
3435         const LDKChannelMessageHandler* operator ->() const { return &self; }
3436         /**
3437          *  Handle an incoming open_channel message from the given peer.
3438          */
3439         inline void handle_open_channel(struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKOpenChannel *NONNULL_PTR msg);
3440         /**
3441          *  Handle an incoming accept_channel message from the given peer.
3442          */
3443         inline void handle_accept_channel(struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKAcceptChannel *NONNULL_PTR msg);
3444         /**
3445          *  Handle an incoming funding_created message from the given peer.
3446          */
3447         inline void handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
3448         /**
3449          *  Handle an incoming funding_signed message from the given peer.
3450          */
3451         inline void handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
3452         /**
3453          *  Handle an incoming funding_locked message from the given peer.
3454          */
3455         inline void handle_funding_locked(struct LDKPublicKey their_node_id, const struct LDKFundingLocked *NONNULL_PTR msg);
3456         /**
3457          *  Handle an incoming shutdown message from the given peer.
3458          */
3459         inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKInitFeatures *NONNULL_PTR their_features, const struct LDKShutdown *NONNULL_PTR msg);
3460         /**
3461          *  Handle an incoming closing_signed message from the given peer.
3462          */
3463         inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
3464         /**
3465          *  Handle an incoming update_add_htlc message from the given peer.
3466          */
3467         inline void handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
3468         /**
3469          *  Handle an incoming update_fulfill_htlc message from the given peer.
3470          */
3471         inline void handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
3472         /**
3473          *  Handle an incoming update_fail_htlc message from the given peer.
3474          */
3475         inline void handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
3476         /**
3477          *  Handle an incoming update_fail_malformed_htlc message from the given peer.
3478          */
3479         inline void handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
3480         /**
3481          *  Handle an incoming commitment_signed message from the given peer.
3482          */
3483         inline void handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
3484         /**
3485          *  Handle an incoming revoke_and_ack message from the given peer.
3486          */
3487         inline void handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
3488         /**
3489          *  Handle an incoming update_fee message from the given peer.
3490          */
3491         inline void handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
3492         /**
3493          *  Handle an incoming announcement_signatures message from the given peer.
3494          */
3495         inline void handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
3496         /**
3497          *  Indicates a connection to the peer failed/an existing connection was lost. If no connection
3498          *  is believed to be possible in the future (eg they're sending us messages we don't
3499          *  understand or indicate they require unknown feature bits), no_connection_possible is set
3500          *  and any outstanding channels should be failed.
3501          */
3502         inline void peer_disconnected(struct LDKPublicKey their_node_id, bool no_connection_possible);
3503         /**
3504          *  Handle a peer reconnecting, possibly generating channel_reestablish message(s).
3505          */
3506         inline void peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg);
3507         /**
3508          *  Handle an incoming channel_reestablish message from the given peer.
3509          */
3510         inline void handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
3511         /**
3512          *  Handle an incoming channel update from the given peer.
3513          */
3514         inline void handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
3515         /**
3516          *  Handle an incoming error message from the given peer.
3517          */
3518         inline void handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
3519 };
3520 class RoutingMessageHandler {
3521 private:
3522         LDKRoutingMessageHandler self;
3523 public:
3524         RoutingMessageHandler(const RoutingMessageHandler&) = delete;
3525         RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
3526         RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
3527         operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
3528         ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
3529         RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
3530         LDKRoutingMessageHandler* operator &() { return &self; }
3531         LDKRoutingMessageHandler* operator ->() { return &self; }
3532         const LDKRoutingMessageHandler* operator &() const { return &self; }
3533         const LDKRoutingMessageHandler* operator ->() const { return &self; }
3534         /**
3535          *  Handle an incoming node_announcement message, returning true if it should be forwarded on,
3536          *  false or returning an Err otherwise.
3537          */
3538         inline LDK::CResult_boolLightningErrorZ handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
3539         /**
3540          *  Handle a channel_announcement message, returning true if it should be forwarded on, false
3541          *  or returning an Err otherwise.
3542          */
3543         inline LDK::CResult_boolLightningErrorZ handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
3544         /**
3545          *  Handle an incoming channel_update message, returning true if it should be forwarded on,
3546          *  false or returning an Err otherwise.
3547          */
3548         inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
3549         /**
3550          *  Gets a subset of the channel announcements and updates required to dump our routing table
3551          *  to a remote node, starting at the short_channel_id indicated by starting_point and
3552          *  including the batch_amount entries immediately higher in numerical value than starting_point.
3553          */
3554         inline LDK::CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements(uint64_t starting_point, uint8_t batch_amount);
3555         /**
3556          *  Gets a subset of the node announcements required to dump our routing table to a remote node,
3557          *  starting at the node *after* the provided publickey and including batch_amount entries
3558          *  immediately higher (as defined by <PublicKey as Ord>::cmp) than starting_point.
3559          *  If None is provided for starting_point, we start at the first node.
3560          *
3561          *  Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
3562          */
3563         inline LDK::CVec_NodeAnnouncementZ get_next_node_announcements(struct LDKPublicKey starting_point, uint8_t batch_amount);
3564         /**
3565          *  Called when a connection is established with a peer. This can be used to
3566          *  perform routing table synchronization using a strategy defined by the
3567          *  implementor.
3568          */
3569         inline void sync_routing_table(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init);
3570         /**
3571          *  Handles the reply of a query we initiated to learn about channels
3572          *  for a given range of blocks. We can expect to receive one or more
3573          *  replies to a single query.
3574          */
3575         inline LDK::CResult_NoneLightningErrorZ handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg);
3576         /**
3577          *  Handles the reply of a query we initiated asking for routing gossip
3578          *  messages for a list of channels. We should receive this message when
3579          *  a node has completed its best effort to send us the pertaining routing
3580          *  gossip messages.
3581          */
3582         inline LDK::CResult_NoneLightningErrorZ handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
3583         /**
3584          *  Handles when a peer asks us to send a list of short_channel_ids
3585          *  for the requested range of blocks.
3586          */
3587         inline LDK::CResult_NoneLightningErrorZ handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
3588         /**
3589          *  Handles when a peer asks us to send routing gossip messages for a
3590          *  list of short_channel_ids.
3591          */
3592         inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
3593 };
3594 class DefaultRouter {
3595 private:
3596         LDKDefaultRouter self;
3597 public:
3598         DefaultRouter(const DefaultRouter&) = delete;
3599         DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
3600         DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
3601         operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
3602         ~DefaultRouter() { DefaultRouter_free(self); }
3603         DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
3604         LDKDefaultRouter* operator &() { return &self; }
3605         LDKDefaultRouter* operator ->() { return &self; }
3606         const LDKDefaultRouter* operator &() const { return &self; }
3607         const LDKDefaultRouter* operator ->() const { return &self; }
3608 };
3609 class Level {
3610 private:
3611         LDKLevel self;
3612 public:
3613         Level(const Level&) = delete;
3614         Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
3615         Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
3616         operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
3617         Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
3618         LDKLevel* operator &() { return &self; }
3619         LDKLevel* operator ->() { return &self; }
3620         const LDKLevel* operator &() const { return &self; }
3621         const LDKLevel* operator ->() const { return &self; }
3622 };
3623 class Record {
3624 private:
3625         LDKRecord self;
3626 public:
3627         Record(const Record&) = delete;
3628         Record(Record&& o) : self(o.self) { memset(&o, 0, sizeof(Record)); }
3629         Record(LDKRecord&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecord)); }
3630         operator LDKRecord() && { LDKRecord res = self; memset(&self, 0, sizeof(LDKRecord)); return res; }
3631         ~Record() { Record_free(self); }
3632         Record& operator=(Record&& o) { Record_free(self); self = o.self; memset(&o, 0, sizeof(Record)); return *this; }
3633         LDKRecord* operator &() { return &self; }
3634         LDKRecord* operator ->() { return &self; }
3635         const LDKRecord* operator &() const { return &self; }
3636         const LDKRecord* operator ->() const { return &self; }
3637 };
3638 class Logger {
3639 private:
3640         LDKLogger self;
3641 public:
3642         Logger(const Logger&) = delete;
3643         Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
3644         Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
3645         operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
3646         ~Logger() { Logger_free(self); }
3647         Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
3648         LDKLogger* operator &() { return &self; }
3649         LDKLogger* operator ->() { return &self; }
3650         const LDKLogger* operator &() const { return &self; }
3651         const LDKLogger* operator ->() const { return &self; }
3652         /**
3653          *  Logs the `Record`
3654          */
3655         inline void log(const struct LDKRecord *NONNULL_PTR record);
3656 };
3657 class MonitorUpdateId {
3658 private:
3659         LDKMonitorUpdateId self;
3660 public:
3661         MonitorUpdateId(const MonitorUpdateId&) = delete;
3662         MonitorUpdateId(MonitorUpdateId&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateId)); }
3663         MonitorUpdateId(LDKMonitorUpdateId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateId)); }
3664         operator LDKMonitorUpdateId() && { LDKMonitorUpdateId res = self; memset(&self, 0, sizeof(LDKMonitorUpdateId)); return res; }
3665         ~MonitorUpdateId() { MonitorUpdateId_free(self); }
3666         MonitorUpdateId& operator=(MonitorUpdateId&& o) { MonitorUpdateId_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateId)); return *this; }
3667         LDKMonitorUpdateId* operator &() { return &self; }
3668         LDKMonitorUpdateId* operator ->() { return &self; }
3669         const LDKMonitorUpdateId* operator &() const { return &self; }
3670         const LDKMonitorUpdateId* operator ->() const { return &self; }
3671 };
3672 class Persist {
3673 private:
3674         LDKPersist self;
3675 public:
3676         Persist(const Persist&) = delete;
3677         Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
3678         Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
3679         operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
3680         ~Persist() { Persist_free(self); }
3681         Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
3682         LDKPersist* operator &() { return &self; }
3683         LDKPersist* operator ->() { return &self; }
3684         const LDKPersist* operator &() const { return &self; }
3685         const LDKPersist* operator ->() const { return &self; }
3686         /**
3687          *  Persist a new channel's data in response to a [`chain::Watch::watch_channel`] call. This is
3688          *  called by [`ChannelManager`] for new channels, or may be called directly, e.g. on startup.
3689          *
3690          *  The data can be stored any way you want, but the identifier provided by LDK is the
3691          *  channel's outpoint (and it is up to you to maintain a correct mapping between the outpoint
3692          *  and the stored channel data). Note that you **must** persist every new monitor to disk.
3693          *
3694          *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
3695          *  if you return [`ChannelMonitorUpdateErr::TemporaryFailure`].
3696          *
3697          *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
3698          *  and [`ChannelMonitorUpdateErr`] for requirements when returning errors.
3699          *
3700          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
3701          *  [`Writeable::write`]: crate::util::ser::Writeable::write
3702          */
3703         inline LDK::CResult_NoneChannelMonitorUpdateErrZ persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
3704         /**
3705          *  Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
3706          *  update.
3707          *
3708          *  Note that on every update, you **must** persist either the [`ChannelMonitorUpdate`] or the
3709          *  updated monitor itself to disk/backups. See the [`Persist`] trait documentation for more
3710          *  details.
3711          *
3712          *  During blockchain synchronization operations, this may be called with no
3713          *  [`ChannelMonitorUpdate`], in which case the full [`ChannelMonitor`] needs to be persisted.
3714          *  Note that after the full [`ChannelMonitor`] is persisted any previous
3715          *  [`ChannelMonitorUpdate`]s which were persisted should be discarded - they can no longer be
3716          *  applied to the persisted [`ChannelMonitor`] as they were already applied.
3717          *
3718          *  If an implementer chooses to persist the updates only, they need to make
3719          *  sure that all the updates are applied to the `ChannelMonitors` *before*
3720          *  the set of channel monitors is given to the `ChannelManager`
3721          *  deserialization routine. See [`ChannelMonitor::update_monitor`] for
3722          *  applying a monitor update to a monitor. If full `ChannelMonitors` are
3723          *  persisted, then there is no need to persist individual updates.
3724          *
3725          *  Note that there could be a performance tradeoff between persisting complete
3726          *  channel monitors on every update vs. persisting only updates and applying
3727          *  them in batches. The size of each monitor grows `O(number of state updates)`
3728          *  whereas updates are small and `O(1)`.
3729          *
3730          *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
3731          *  if you return [`ChannelMonitorUpdateErr::TemporaryFailure`].
3732          *
3733          *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
3734          *  [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
3735          *  [`ChannelMonitorUpdateErr`] for requirements when returning errors.
3736          *
3737          *  [`Writeable::write`]: crate::util::ser::Writeable::write
3738          *
3739          *  Note that update (or a relevant inner pointer) may be NULL or all-0s to represent None
3740          */
3741         inline LDK::CResult_NoneChannelMonitorUpdateErrZ update_persisted_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
3742 };
3743 class LockedChannelMonitor {
3744 private:
3745         LDKLockedChannelMonitor self;
3746 public:
3747         LockedChannelMonitor(const LockedChannelMonitor&) = delete;
3748         LockedChannelMonitor(LockedChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(LockedChannelMonitor)); }
3749         LockedChannelMonitor(LDKLockedChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedChannelMonitor)); }
3750         operator LDKLockedChannelMonitor() && { LDKLockedChannelMonitor res = self; memset(&self, 0, sizeof(LDKLockedChannelMonitor)); return res; }
3751         ~LockedChannelMonitor() { LockedChannelMonitor_free(self); }
3752         LockedChannelMonitor& operator=(LockedChannelMonitor&& o) { LockedChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(LockedChannelMonitor)); return *this; }
3753         LDKLockedChannelMonitor* operator &() { return &self; }
3754         LDKLockedChannelMonitor* operator ->() { return &self; }
3755         const LDKLockedChannelMonitor* operator &() const { return &self; }
3756         const LDKLockedChannelMonitor* operator ->() const { return &self; }
3757 };
3758 class ChainMonitor {
3759 private:
3760         LDKChainMonitor self;
3761 public:
3762         ChainMonitor(const ChainMonitor&) = delete;
3763         ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
3764         ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
3765         operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
3766         ~ChainMonitor() { ChainMonitor_free(self); }
3767         ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
3768         LDKChainMonitor* operator &() { return &self; }
3769         LDKChainMonitor* operator ->() { return &self; }
3770         const LDKChainMonitor* operator &() const { return &self; }
3771         const LDKChainMonitor* operator ->() const { return &self; }
3772 };
3773 class CVec_SpendableOutputDescriptorZ {
3774 private:
3775         LDKCVec_SpendableOutputDescriptorZ self;
3776 public:
3777         CVec_SpendableOutputDescriptorZ(const CVec_SpendableOutputDescriptorZ&) = delete;
3778         CVec_SpendableOutputDescriptorZ(CVec_SpendableOutputDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); }
3779         CVec_SpendableOutputDescriptorZ(LDKCVec_SpendableOutputDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); }
3780         operator LDKCVec_SpendableOutputDescriptorZ() && { LDKCVec_SpendableOutputDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); return res; }
3781         ~CVec_SpendableOutputDescriptorZ() { CVec_SpendableOutputDescriptorZ_free(self); }
3782         CVec_SpendableOutputDescriptorZ& operator=(CVec_SpendableOutputDescriptorZ&& o) { CVec_SpendableOutputDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); return *this; }
3783         LDKCVec_SpendableOutputDescriptorZ* operator &() { return &self; }
3784         LDKCVec_SpendableOutputDescriptorZ* operator ->() { return &self; }
3785         const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
3786         const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
3787 };
3788 class CResult_LockedChannelMonitorNoneZ {
3789 private:
3790         LDKCResult_LockedChannelMonitorNoneZ self;
3791 public:
3792         CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
3793         CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
3794         CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
3795         operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
3796         ~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
3797         CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
3798         LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
3799         LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
3800         const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
3801         const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
3802 };
3803 class CResult_PhantomRouteHintsDecodeErrorZ {
3804 private:
3805         LDKCResult_PhantomRouteHintsDecodeErrorZ self;
3806 public:
3807         CResult_PhantomRouteHintsDecodeErrorZ(const CResult_PhantomRouteHintsDecodeErrorZ&) = delete;
3808         CResult_PhantomRouteHintsDecodeErrorZ(CResult_PhantomRouteHintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); }
3809         CResult_PhantomRouteHintsDecodeErrorZ(LDKCResult_PhantomRouteHintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); }
3810         operator LDKCResult_PhantomRouteHintsDecodeErrorZ() && { LDKCResult_PhantomRouteHintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); return res; }
3811         ~CResult_PhantomRouteHintsDecodeErrorZ() { CResult_PhantomRouteHintsDecodeErrorZ_free(self); }
3812         CResult_PhantomRouteHintsDecodeErrorZ& operator=(CResult_PhantomRouteHintsDecodeErrorZ&& o) { CResult_PhantomRouteHintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); return *this; }
3813         LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() { return &self; }
3814         LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() { return &self; }
3815         const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
3816         const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
3817 };
3818 class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
3819 private:
3820         LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
3821 public:
3822         CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(const CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&) = delete;
3823         CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
3824         CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
3825         operator LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() && { LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return res; }
3826         ~CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); }
3827         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; }
3828         LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() { return &self; }
3829         LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() { return &self; }
3830         const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() const { return &self; }
3831         const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() const { return &self; }
3832 };
3833 class CResult_ScoringParametersDecodeErrorZ {
3834 private:
3835         LDKCResult_ScoringParametersDecodeErrorZ self;
3836 public:
3837         CResult_ScoringParametersDecodeErrorZ(const CResult_ScoringParametersDecodeErrorZ&) = delete;
3838         CResult_ScoringParametersDecodeErrorZ(CResult_ScoringParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ScoringParametersDecodeErrorZ)); }
3839         CResult_ScoringParametersDecodeErrorZ(LDKCResult_ScoringParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ScoringParametersDecodeErrorZ)); }
3840         operator LDKCResult_ScoringParametersDecodeErrorZ() && { LDKCResult_ScoringParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ScoringParametersDecodeErrorZ)); return res; }
3841         ~CResult_ScoringParametersDecodeErrorZ() { CResult_ScoringParametersDecodeErrorZ_free(self); }
3842         CResult_ScoringParametersDecodeErrorZ& operator=(CResult_ScoringParametersDecodeErrorZ&& o) { CResult_ScoringParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ScoringParametersDecodeErrorZ)); return *this; }
3843         LDKCResult_ScoringParametersDecodeErrorZ* operator &() { return &self; }
3844         LDKCResult_ScoringParametersDecodeErrorZ* operator ->() { return &self; }
3845         const LDKCResult_ScoringParametersDecodeErrorZ* operator &() const { return &self; }
3846         const LDKCResult_ScoringParametersDecodeErrorZ* operator ->() const { return &self; }
3847 };
3848 class CResult_HTLCUpdateDecodeErrorZ {
3849 private:
3850         LDKCResult_HTLCUpdateDecodeErrorZ self;
3851 public:
3852         CResult_HTLCUpdateDecodeErrorZ(const CResult_HTLCUpdateDecodeErrorZ&) = delete;
3853         CResult_HTLCUpdateDecodeErrorZ(CResult_HTLCUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); }
3854         CResult_HTLCUpdateDecodeErrorZ(LDKCResult_HTLCUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); }
3855         operator LDKCResult_HTLCUpdateDecodeErrorZ() && { LDKCResult_HTLCUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); return res; }
3856         ~CResult_HTLCUpdateDecodeErrorZ() { CResult_HTLCUpdateDecodeErrorZ_free(self); }
3857         CResult_HTLCUpdateDecodeErrorZ& operator=(CResult_HTLCUpdateDecodeErrorZ&& o) { CResult_HTLCUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); return *this; }
3858         LDKCResult_HTLCUpdateDecodeErrorZ* operator &() { return &self; }
3859         LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() { return &self; }
3860         const LDKCResult_HTLCUpdateDecodeErrorZ* operator &() const { return &self; }
3861         const LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() const { return &self; }
3862 };
3863 class C2Tuple_SignatureCVec_SignatureZZ {
3864 private:
3865         LDKC2Tuple_SignatureCVec_SignatureZZ self;
3866 public:
3867         C2Tuple_SignatureCVec_SignatureZZ(const C2Tuple_SignatureCVec_SignatureZZ&) = delete;
3868         C2Tuple_SignatureCVec_SignatureZZ(C2Tuple_SignatureCVec_SignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); }
3869         C2Tuple_SignatureCVec_SignatureZZ(LDKC2Tuple_SignatureCVec_SignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); }
3870         operator LDKC2Tuple_SignatureCVec_SignatureZZ() && { LDKC2Tuple_SignatureCVec_SignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); return res; }
3871         ~C2Tuple_SignatureCVec_SignatureZZ() { C2Tuple_SignatureCVec_SignatureZZ_free(self); }
3872         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; }
3873         LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() { return &self; }
3874         LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() { return &self; }
3875         const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; }
3876         const LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() const { return &self; }
3877 };
3878 class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
3879 private:
3880         LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ self;
3881 public:
3882         CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(const CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&) = delete;
3883         CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
3884         CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
3885         operator LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() && { LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return res; }
3886         ~CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); }
3887         CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ& operator=(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return *this; }
3888         LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() { return &self; }
3889         LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() { return &self; }
3890         const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() const { return &self; }
3891         const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() const { return &self; }
3892 };
3893 class CVec_C2Tuple_u32TxOutZZ {
3894 private:
3895         LDKCVec_C2Tuple_u32TxOutZZ self;
3896 public:
3897         CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
3898         CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
3899         CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
3900         operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
3901         ~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
3902         CVec_C2Tuple_u32TxOutZZ& operator=(CVec_C2Tuple_u32TxOutZZ&& o) { CVec_C2Tuple_u32TxOutZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); return *this; }
3903         LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
3904         LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
3905         const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
3906         const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
3907 };
3908 class CResult_ChannelInfoDecodeErrorZ {
3909 private:
3910         LDKCResult_ChannelInfoDecodeErrorZ self;
3911 public:
3912         CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
3913         CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
3914         CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
3915         operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
3916         ~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
3917         CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
3918         LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
3919         LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
3920         const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
3921         const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
3922 };
3923 class CResult_FundingCreatedDecodeErrorZ {
3924 private:
3925         LDKCResult_FundingCreatedDecodeErrorZ self;
3926 public:
3927         CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
3928         CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
3929         CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
3930         operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
3931         ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
3932         CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
3933         LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
3934         LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
3935         const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
3936         const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
3937 };
3938 class CResult_ChannelAnnouncementDecodeErrorZ {
3939 private:
3940         LDKCResult_ChannelAnnouncementDecodeErrorZ self;
3941 public:
3942         CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
3943         CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
3944         CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
3945         operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
3946         ~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
3947         CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
3948         LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
3949         LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
3950         const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
3951         const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
3952 };
3953 class CVec_OutPointZ {
3954 private:
3955         LDKCVec_OutPointZ self;
3956 public:
3957         CVec_OutPointZ(const CVec_OutPointZ&) = delete;
3958         CVec_OutPointZ(CVec_OutPointZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutPointZ)); }
3959         CVec_OutPointZ(LDKCVec_OutPointZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutPointZ)); }
3960         operator LDKCVec_OutPointZ() && { LDKCVec_OutPointZ res = self; memset(&self, 0, sizeof(LDKCVec_OutPointZ)); return res; }
3961         ~CVec_OutPointZ() { CVec_OutPointZ_free(self); }
3962         CVec_OutPointZ& operator=(CVec_OutPointZ&& o) { CVec_OutPointZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutPointZ)); return *this; }
3963         LDKCVec_OutPointZ* operator &() { return &self; }
3964         LDKCVec_OutPointZ* operator ->() { return &self; }
3965         const LDKCVec_OutPointZ* operator &() const { return &self; }
3966         const LDKCVec_OutPointZ* operator ->() const { return &self; }
3967 };
3968 class CResult_PositiveTimestampCreationErrorZ {
3969 private:
3970         LDKCResult_PositiveTimestampCreationErrorZ self;
3971 public:
3972         CResult_PositiveTimestampCreationErrorZ(const CResult_PositiveTimestampCreationErrorZ&) = delete;
3973         CResult_PositiveTimestampCreationErrorZ(CResult_PositiveTimestampCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); }
3974         CResult_PositiveTimestampCreationErrorZ(LDKCResult_PositiveTimestampCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); }
3975         operator LDKCResult_PositiveTimestampCreationErrorZ() && { LDKCResult_PositiveTimestampCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); return res; }
3976         ~CResult_PositiveTimestampCreationErrorZ() { CResult_PositiveTimestampCreationErrorZ_free(self); }
3977         CResult_PositiveTimestampCreationErrorZ& operator=(CResult_PositiveTimestampCreationErrorZ&& o) { CResult_PositiveTimestampCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); return *this; }
3978         LDKCResult_PositiveTimestampCreationErrorZ* operator &() { return &self; }
3979         LDKCResult_PositiveTimestampCreationErrorZ* operator ->() { return &self; }
3980         const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
3981         const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
3982 };
3983 class CResult_CVec_u8ZPeerHandleErrorZ {
3984 private:
3985         LDKCResult_CVec_u8ZPeerHandleErrorZ self;
3986 public:
3987         CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
3988         CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
3989         CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
3990         operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
3991         ~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
3992         CResult_CVec_u8ZPeerHandleErrorZ& operator=(CResult_CVec_u8ZPeerHandleErrorZ&& o) { CResult_CVec_u8ZPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); return *this; }
3993         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
3994         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
3995         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
3996         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
3997 };
3998 class CResult_InvoiceFeaturesDecodeErrorZ {
3999 private:
4000         LDKCResult_InvoiceFeaturesDecodeErrorZ self;
4001 public:
4002         CResult_InvoiceFeaturesDecodeErrorZ(const CResult_InvoiceFeaturesDecodeErrorZ&) = delete;
4003         CResult_InvoiceFeaturesDecodeErrorZ(CResult_InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); }
4004         CResult_InvoiceFeaturesDecodeErrorZ(LDKCResult_InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); }
4005         operator LDKCResult_InvoiceFeaturesDecodeErrorZ() && { LDKCResult_InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); return res; }
4006         ~CResult_InvoiceFeaturesDecodeErrorZ() { CResult_InvoiceFeaturesDecodeErrorZ_free(self); }
4007         CResult_InvoiceFeaturesDecodeErrorZ& operator=(CResult_InvoiceFeaturesDecodeErrorZ&& o) { CResult_InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); return *this; }
4008         LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
4009         LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
4010         const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
4011         const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
4012 };
4013 class COption_NetworkUpdateZ {
4014 private:
4015         LDKCOption_NetworkUpdateZ self;
4016 public:
4017         COption_NetworkUpdateZ(const COption_NetworkUpdateZ&) = delete;
4018         COption_NetworkUpdateZ(COption_NetworkUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NetworkUpdateZ)); }
4019         COption_NetworkUpdateZ(LDKCOption_NetworkUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NetworkUpdateZ)); }
4020         operator LDKCOption_NetworkUpdateZ() && { LDKCOption_NetworkUpdateZ res = self; memset(&self, 0, sizeof(LDKCOption_NetworkUpdateZ)); return res; }
4021         ~COption_NetworkUpdateZ() { COption_NetworkUpdateZ_free(self); }
4022         COption_NetworkUpdateZ& operator=(COption_NetworkUpdateZ&& o) { COption_NetworkUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NetworkUpdateZ)); return *this; }
4023         LDKCOption_NetworkUpdateZ* operator &() { return &self; }
4024         LDKCOption_NetworkUpdateZ* operator ->() { return &self; }
4025         const LDKCOption_NetworkUpdateZ* operator &() const { return &self; }
4026         const LDKCOption_NetworkUpdateZ* operator ->() const { return &self; }
4027 };
4028 class COption_u64Z {
4029 private:
4030         LDKCOption_u64Z self;
4031 public:
4032         COption_u64Z(const COption_u64Z&) = delete;
4033         COption_u64Z(COption_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u64Z)); }
4034         COption_u64Z(LDKCOption_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u64Z)); }
4035         operator LDKCOption_u64Z() && { LDKCOption_u64Z res = self; memset(&self, 0, sizeof(LDKCOption_u64Z)); return res; }
4036         ~COption_u64Z() { COption_u64Z_free(self); }
4037         COption_u64Z& operator=(COption_u64Z&& o) { COption_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u64Z)); return *this; }
4038         LDKCOption_u64Z* operator &() { return &self; }
4039         LDKCOption_u64Z* operator ->() { return &self; }
4040         const LDKCOption_u64Z* operator &() const { return &self; }
4041         const LDKCOption_u64Z* operator ->() const { return &self; }
4042 };
4043 class CResult_TxOutAccessErrorZ {
4044 private:
4045         LDKCResult_TxOutAccessErrorZ self;
4046 public:
4047         CResult_TxOutAccessErrorZ(const CResult_TxOutAccessErrorZ&) = delete;
4048         CResult_TxOutAccessErrorZ(CResult_TxOutAccessErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutAccessErrorZ)); }
4049         CResult_TxOutAccessErrorZ(LDKCResult_TxOutAccessErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutAccessErrorZ)); }
4050         operator LDKCResult_TxOutAccessErrorZ() && { LDKCResult_TxOutAccessErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutAccessErrorZ)); return res; }
4051         ~CResult_TxOutAccessErrorZ() { CResult_TxOutAccessErrorZ_free(self); }
4052         CResult_TxOutAccessErrorZ& operator=(CResult_TxOutAccessErrorZ&& o) { CResult_TxOutAccessErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutAccessErrorZ)); return *this; }
4053         LDKCResult_TxOutAccessErrorZ* operator &() { return &self; }
4054         LDKCResult_TxOutAccessErrorZ* operator ->() { return &self; }
4055         const LDKCResult_TxOutAccessErrorZ* operator &() const { return &self; }
4056         const LDKCResult_TxOutAccessErrorZ* operator ->() const { return &self; }
4057 };
4058 class CResult_TrustedClosingTransactionNoneZ {
4059 private:
4060         LDKCResult_TrustedClosingTransactionNoneZ self;
4061 public:
4062         CResult_TrustedClosingTransactionNoneZ(const CResult_TrustedClosingTransactionNoneZ&) = delete;
4063         CResult_TrustedClosingTransactionNoneZ(CResult_TrustedClosingTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); }
4064         CResult_TrustedClosingTransactionNoneZ(LDKCResult_TrustedClosingTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); }
4065         operator LDKCResult_TrustedClosingTransactionNoneZ() && { LDKCResult_TrustedClosingTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); return res; }
4066         ~CResult_TrustedClosingTransactionNoneZ() { CResult_TrustedClosingTransactionNoneZ_free(self); }
4067         CResult_TrustedClosingTransactionNoneZ& operator=(CResult_TrustedClosingTransactionNoneZ&& o) { CResult_TrustedClosingTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); return *this; }
4068         LDKCResult_TrustedClosingTransactionNoneZ* operator &() { return &self; }
4069         LDKCResult_TrustedClosingTransactionNoneZ* operator ->() { return &self; }
4070         const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
4071         const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
4072 };
4073 class CResult_PaymentPreimageAPIErrorZ {
4074 private:
4075         LDKCResult_PaymentPreimageAPIErrorZ self;
4076 public:
4077         CResult_PaymentPreimageAPIErrorZ(const CResult_PaymentPreimageAPIErrorZ&) = delete;
4078         CResult_PaymentPreimageAPIErrorZ(CResult_PaymentPreimageAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentPreimageAPIErrorZ)); }
4079         CResult_PaymentPreimageAPIErrorZ(LDKCResult_PaymentPreimageAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentPreimageAPIErrorZ)); }
4080         operator LDKCResult_PaymentPreimageAPIErrorZ() && { LDKCResult_PaymentPreimageAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentPreimageAPIErrorZ)); return res; }
4081         ~CResult_PaymentPreimageAPIErrorZ() { CResult_PaymentPreimageAPIErrorZ_free(self); }
4082         CResult_PaymentPreimageAPIErrorZ& operator=(CResult_PaymentPreimageAPIErrorZ&& o) { CResult_PaymentPreimageAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentPreimageAPIErrorZ)); return *this; }
4083         LDKCResult_PaymentPreimageAPIErrorZ* operator &() { return &self; }
4084         LDKCResult_PaymentPreimageAPIErrorZ* operator ->() { return &self; }
4085         const LDKCResult_PaymentPreimageAPIErrorZ* operator &() const { return &self; }
4086         const LDKCResult_PaymentPreimageAPIErrorZ* operator ->() const { return &self; }
4087 };
4088 class CResult_ChannelMonitorUpdateDecodeErrorZ {
4089 private:
4090         LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
4091 public:
4092         CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
4093         CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
4094         CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
4095         operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
4096         ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
4097         CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
4098         LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
4099         LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
4100         const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
4101         const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
4102 };
4103 class CResult_RouteHintDecodeErrorZ {
4104 private:
4105         LDKCResult_RouteHintDecodeErrorZ self;
4106 public:
4107         CResult_RouteHintDecodeErrorZ(const CResult_RouteHintDecodeErrorZ&) = delete;
4108         CResult_RouteHintDecodeErrorZ(CResult_RouteHintDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); }
4109         CResult_RouteHintDecodeErrorZ(LDKCResult_RouteHintDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); }
4110         operator LDKCResult_RouteHintDecodeErrorZ() && { LDKCResult_RouteHintDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); return res; }
4111         ~CResult_RouteHintDecodeErrorZ() { CResult_RouteHintDecodeErrorZ_free(self); }
4112         CResult_RouteHintDecodeErrorZ& operator=(CResult_RouteHintDecodeErrorZ&& o) { CResult_RouteHintDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); return *this; }
4113         LDKCResult_RouteHintDecodeErrorZ* operator &() { return &self; }
4114         LDKCResult_RouteHintDecodeErrorZ* operator ->() { return &self; }
4115         const LDKCResult_RouteHintDecodeErrorZ* operator &() const { return &self; }
4116         const LDKCResult_RouteHintDecodeErrorZ* operator ->() const { return &self; }
4117 };
4118 class C2Tuple_PublicKeyTypeZ {
4119 private:
4120         LDKC2Tuple_PublicKeyTypeZ self;
4121 public:
4122         C2Tuple_PublicKeyTypeZ(const C2Tuple_PublicKeyTypeZ&) = delete;
4123         C2Tuple_PublicKeyTypeZ(C2Tuple_PublicKeyTypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); }
4124         C2Tuple_PublicKeyTypeZ(LDKC2Tuple_PublicKeyTypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); }
4125         operator LDKC2Tuple_PublicKeyTypeZ() && { LDKC2Tuple_PublicKeyTypeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); return res; }
4126         ~C2Tuple_PublicKeyTypeZ() { C2Tuple_PublicKeyTypeZ_free(self); }
4127         C2Tuple_PublicKeyTypeZ& operator=(C2Tuple_PublicKeyTypeZ&& o) { C2Tuple_PublicKeyTypeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); return *this; }
4128         LDKC2Tuple_PublicKeyTypeZ* operator &() { return &self; }
4129         LDKC2Tuple_PublicKeyTypeZ* operator ->() { return &self; }
4130         const LDKC2Tuple_PublicKeyTypeZ* operator &() const { return &self; }
4131         const LDKC2Tuple_PublicKeyTypeZ* operator ->() const { return &self; }
4132 };
4133 class CResult_NetAddressDecodeErrorZ {
4134 private:
4135         LDKCResult_NetAddressDecodeErrorZ self;
4136 public:
4137         CResult_NetAddressDecodeErrorZ(const CResult_NetAddressDecodeErrorZ&) = delete;
4138         CResult_NetAddressDecodeErrorZ(CResult_NetAddressDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetAddressDecodeErrorZ)); }
4139         CResult_NetAddressDecodeErrorZ(LDKCResult_NetAddressDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetAddressDecodeErrorZ)); }
4140         operator LDKCResult_NetAddressDecodeErrorZ() && { LDKCResult_NetAddressDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NetAddressDecodeErrorZ)); return res; }
4141         ~CResult_NetAddressDecodeErrorZ() { CResult_NetAddressDecodeErrorZ_free(self); }
4142         CResult_NetAddressDecodeErrorZ& operator=(CResult_NetAddressDecodeErrorZ&& o) { CResult_NetAddressDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetAddressDecodeErrorZ)); return *this; }
4143         LDKCResult_NetAddressDecodeErrorZ* operator &() { return &self; }
4144         LDKCResult_NetAddressDecodeErrorZ* operator ->() { return &self; }
4145         const LDKCResult_NetAddressDecodeErrorZ* operator &() const { return &self; }
4146         const LDKCResult_NetAddressDecodeErrorZ* operator ->() const { return &self; }
4147 };
4148 class CResult_ChannelReestablishDecodeErrorZ {
4149 private:
4150         LDKCResult_ChannelReestablishDecodeErrorZ self;
4151 public:
4152         CResult_ChannelReestablishDecodeErrorZ(const CResult_ChannelReestablishDecodeErrorZ&) = delete;
4153         CResult_ChannelReestablishDecodeErrorZ(CResult_ChannelReestablishDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); }
4154         CResult_ChannelReestablishDecodeErrorZ(LDKCResult_ChannelReestablishDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); }
4155         operator LDKCResult_ChannelReestablishDecodeErrorZ() && { LDKCResult_ChannelReestablishDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); return res; }
4156         ~CResult_ChannelReestablishDecodeErrorZ() { CResult_ChannelReestablishDecodeErrorZ_free(self); }
4157         CResult_ChannelReestablishDecodeErrorZ& operator=(CResult_ChannelReestablishDecodeErrorZ&& o) { CResult_ChannelReestablishDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); return *this; }
4158         LDKCResult_ChannelReestablishDecodeErrorZ* operator &() { return &self; }
4159         LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() { return &self; }
4160         const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
4161         const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
4162 };
4163 class CResult_CommitmentSignedDecodeErrorZ {
4164 private:
4165         LDKCResult_CommitmentSignedDecodeErrorZ self;
4166 public:
4167         CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
4168         CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
4169         CResult_CommitmentSignedDecodeErrorZ(LDKCResult_CommitmentSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); }
4170         operator LDKCResult_CommitmentSignedDecodeErrorZ() && { LDKCResult_CommitmentSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); return res; }
4171         ~CResult_CommitmentSignedDecodeErrorZ() { CResult_CommitmentSignedDecodeErrorZ_free(self); }
4172         CResult_CommitmentSignedDecodeErrorZ& operator=(CResult_CommitmentSignedDecodeErrorZ&& o) { CResult_CommitmentSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); return *this; }
4173         LDKCResult_CommitmentSignedDecodeErrorZ* operator &() { return &self; }
4174         LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() { return &self; }
4175         const LDKCResult_CommitmentSignedDecodeErrorZ* operator &() const { return &self; }
4176         const LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() const { return &self; }
4177 };
4178 class CVec_UpdateAddHTLCZ {
4179 private:
4180         LDKCVec_UpdateAddHTLCZ self;
4181 public:
4182         CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
4183         CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
4184         CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
4185         operator LDKCVec_UpdateAddHTLCZ() && { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
4186         ~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
4187         CVec_UpdateAddHTLCZ& operator=(CVec_UpdateAddHTLCZ&& o) { CVec_UpdateAddHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); return *this; }
4188         LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
4189         LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
4190         const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
4191         const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
4192 };
4193 class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
4194 private:
4195         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
4196 public:
4197         CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
4198         CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
4199         CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
4200         operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
4201         ~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
4202         CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
4203         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
4204         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
4205         const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
4206         const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
4207 };
4208 class COption_u32Z {
4209 private:
4210         LDKCOption_u32Z self;
4211 public:
4212         COption_u32Z(const COption_u32Z&) = delete;
4213         COption_u32Z(COption_u32Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u32Z)); }
4214         COption_u32Z(LDKCOption_u32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u32Z)); }
4215         operator LDKCOption_u32Z() && { LDKCOption_u32Z res = self; memset(&self, 0, sizeof(LDKCOption_u32Z)); return res; }
4216         ~COption_u32Z() { COption_u32Z_free(self); }
4217         COption_u32Z& operator=(COption_u32Z&& o) { COption_u32Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u32Z)); return *this; }
4218         LDKCOption_u32Z* operator &() { return &self; }
4219         LDKCOption_u32Z* operator ->() { return &self; }
4220         const LDKCOption_u32Z* operator &() const { return &self; }
4221         const LDKCOption_u32Z* operator ->() const { return &self; }
4222 };
4223 class CResult_InitFeaturesDecodeErrorZ {
4224 private:
4225         LDKCResult_InitFeaturesDecodeErrorZ self;
4226 public:
4227         CResult_InitFeaturesDecodeErrorZ(const CResult_InitFeaturesDecodeErrorZ&) = delete;
4228         CResult_InitFeaturesDecodeErrorZ(CResult_InitFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); }
4229         CResult_InitFeaturesDecodeErrorZ(LDKCResult_InitFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); }
4230         operator LDKCResult_InitFeaturesDecodeErrorZ() && { LDKCResult_InitFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); return res; }
4231         ~CResult_InitFeaturesDecodeErrorZ() { CResult_InitFeaturesDecodeErrorZ_free(self); }
4232         CResult_InitFeaturesDecodeErrorZ& operator=(CResult_InitFeaturesDecodeErrorZ&& o) { CResult_InitFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); return *this; }
4233         LDKCResult_InitFeaturesDecodeErrorZ* operator &() { return &self; }
4234         LDKCResult_InitFeaturesDecodeErrorZ* operator ->() { return &self; }
4235         const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; }
4236         const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; }
4237 };
4238 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
4239 private:
4240         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
4241 public:
4242         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(const CResult_StaticPaymentOutputDescriptorDecodeErrorZ&) = delete;
4243         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
4244         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
4245         operator LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return res; }
4246         ~CResult_StaticPaymentOutputDescriptorDecodeErrorZ() { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); }
4247         CResult_StaticPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return *this; }
4248         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
4249         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
4250         const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
4251         const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
4252 };
4253 class CResult_PaymentIdPaymentSendFailureZ {
4254 private:
4255         LDKCResult_PaymentIdPaymentSendFailureZ self;
4256 public:
4257         CResult_PaymentIdPaymentSendFailureZ(const CResult_PaymentIdPaymentSendFailureZ&) = delete;
4258         CResult_PaymentIdPaymentSendFailureZ(CResult_PaymentIdPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentIdPaymentSendFailureZ)); }
4259         CResult_PaymentIdPaymentSendFailureZ(LDKCResult_PaymentIdPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentIdPaymentSendFailureZ)); }
4260         operator LDKCResult_PaymentIdPaymentSendFailureZ() && { LDKCResult_PaymentIdPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentIdPaymentSendFailureZ)); return res; }
4261         ~CResult_PaymentIdPaymentSendFailureZ() { CResult_PaymentIdPaymentSendFailureZ_free(self); }
4262         CResult_PaymentIdPaymentSendFailureZ& operator=(CResult_PaymentIdPaymentSendFailureZ&& o) { CResult_PaymentIdPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentIdPaymentSendFailureZ)); return *this; }
4263         LDKCResult_PaymentIdPaymentSendFailureZ* operator &() { return &self; }
4264         LDKCResult_PaymentIdPaymentSendFailureZ* operator ->() { return &self; }
4265         const LDKCResult_PaymentIdPaymentSendFailureZ* operator &() const { return &self; }
4266         const LDKCResult_PaymentIdPaymentSendFailureZ* operator ->() const { return &self; }
4267 };
4268 class CResult_ReplyChannelRangeDecodeErrorZ {
4269 private:
4270         LDKCResult_ReplyChannelRangeDecodeErrorZ self;
4271 public:
4272         CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
4273         CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
4274         CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
4275         operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
4276         ~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
4277         CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
4278         LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
4279         LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
4280         const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
4281         const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
4282 };
4283 class CResult_CommitmentTransactionDecodeErrorZ {
4284 private:
4285         LDKCResult_CommitmentTransactionDecodeErrorZ self;
4286 public:
4287         CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
4288         CResult_CommitmentTransactionDecodeErrorZ(CResult_CommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); }
4289         CResult_CommitmentTransactionDecodeErrorZ(LDKCResult_CommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); }
4290         operator LDKCResult_CommitmentTransactionDecodeErrorZ() && { LDKCResult_CommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); return res; }
4291         ~CResult_CommitmentTransactionDecodeErrorZ() { CResult_CommitmentTransactionDecodeErrorZ_free(self); }
4292         CResult_CommitmentTransactionDecodeErrorZ& operator=(CResult_CommitmentTransactionDecodeErrorZ&& o) { CResult_CommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); return *this; }
4293         LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() { return &self; }
4294         LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
4295         const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
4296         const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
4297 };
4298 class COption_C2Tuple_usizeTransactionZZ {
4299 private:
4300         LDKCOption_C2Tuple_usizeTransactionZZ self;
4301 public:
4302         COption_C2Tuple_usizeTransactionZZ(const COption_C2Tuple_usizeTransactionZZ&) = delete;
4303         COption_C2Tuple_usizeTransactionZZ(COption_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_usizeTransactionZZ)); }
4304         COption_C2Tuple_usizeTransactionZZ(LDKCOption_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); }
4305         operator LDKCOption_C2Tuple_usizeTransactionZZ() && { LDKCOption_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); return res; }
4306         ~COption_C2Tuple_usizeTransactionZZ() { COption_C2Tuple_usizeTransactionZZ_free(self); }
4307         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; }
4308         LDKCOption_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
4309         LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
4310         const LDKCOption_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
4311         const LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
4312 };
4313 class CResult_TransactionNoneZ {
4314 private:
4315         LDKCResult_TransactionNoneZ self;
4316 public:
4317         CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
4318         CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
4319         CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
4320         operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
4321         ~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
4322         CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
4323         LDKCResult_TransactionNoneZ* operator &() { return &self; }
4324         LDKCResult_TransactionNoneZ* operator ->() { return &self; }
4325         const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
4326         const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
4327 };
4328 class CResult_SignedRawInvoiceNoneZ {
4329 private:
4330         LDKCResult_SignedRawInvoiceNoneZ self;
4331 public:
4332         CResult_SignedRawInvoiceNoneZ(const CResult_SignedRawInvoiceNoneZ&) = delete;
4333         CResult_SignedRawInvoiceNoneZ(CResult_SignedRawInvoiceNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawInvoiceNoneZ)); }
4334         CResult_SignedRawInvoiceNoneZ(LDKCResult_SignedRawInvoiceNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawInvoiceNoneZ)); }
4335         operator LDKCResult_SignedRawInvoiceNoneZ() && { LDKCResult_SignedRawInvoiceNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawInvoiceNoneZ)); return res; }
4336         ~CResult_SignedRawInvoiceNoneZ() { CResult_SignedRawInvoiceNoneZ_free(self); }
4337         CResult_SignedRawInvoiceNoneZ& operator=(CResult_SignedRawInvoiceNoneZ&& o) { CResult_SignedRawInvoiceNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawInvoiceNoneZ)); return *this; }
4338         LDKCResult_SignedRawInvoiceNoneZ* operator &() { return &self; }
4339         LDKCResult_SignedRawInvoiceNoneZ* operator ->() { return &self; }
4340         const LDKCResult_SignedRawInvoiceNoneZ* operator &() const { return &self; }
4341         const LDKCResult_SignedRawInvoiceNoneZ* operator ->() const { return &self; }
4342 };
4343 class CResult_ClosingSignedFeeRangeDecodeErrorZ {
4344 private:
4345         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
4346 public:
4347         CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
4348         CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
4349         CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
4350         operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
4351         ~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
4352         CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
4353         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
4354         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
4355         const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
4356         const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
4357 };
4358 class CResult_PingDecodeErrorZ {
4359 private:
4360         LDKCResult_PingDecodeErrorZ self;
4361 public:
4362         CResult_PingDecodeErrorZ(const CResult_PingDecodeErrorZ&) = delete;
4363         CResult_PingDecodeErrorZ(CResult_PingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); }
4364         CResult_PingDecodeErrorZ(LDKCResult_PingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); }
4365         operator LDKCResult_PingDecodeErrorZ() && { LDKCResult_PingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); return res; }
4366         ~CResult_PingDecodeErrorZ() { CResult_PingDecodeErrorZ_free(self); }
4367         CResult_PingDecodeErrorZ& operator=(CResult_PingDecodeErrorZ&& o) { CResult_PingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); return *this; }
4368         LDKCResult_PingDecodeErrorZ* operator &() { return &self; }
4369         LDKCResult_PingDecodeErrorZ* operator ->() { return &self; }
4370         const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
4371         const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
4372 };
4373 class CResult_GossipTimestampFilterDecodeErrorZ {
4374 private:
4375         LDKCResult_GossipTimestampFilterDecodeErrorZ self;
4376 public:
4377         CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
4378         CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
4379         CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
4380         operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
4381         ~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
4382         CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
4383         LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
4384         LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
4385         const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
4386         const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
4387 };
4388 class CResult_InvoiceSignOrCreationErrorZ {
4389 private:
4390         LDKCResult_InvoiceSignOrCreationErrorZ self;
4391 public:
4392         CResult_InvoiceSignOrCreationErrorZ(const CResult_InvoiceSignOrCreationErrorZ&) = delete;
4393         CResult_InvoiceSignOrCreationErrorZ(CResult_InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); }
4394         CResult_InvoiceSignOrCreationErrorZ(LDKCResult_InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); }
4395         operator LDKCResult_InvoiceSignOrCreationErrorZ() && { LDKCResult_InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); return res; }
4396         ~CResult_InvoiceSignOrCreationErrorZ() { CResult_InvoiceSignOrCreationErrorZ_free(self); }
4397         CResult_InvoiceSignOrCreationErrorZ& operator=(CResult_InvoiceSignOrCreationErrorZ&& o) { CResult_InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); return *this; }
4398         LDKCResult_InvoiceSignOrCreationErrorZ* operator &() { return &self; }
4399         LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
4400         const LDKCResult_InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
4401         const LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
4402 };
4403 class CVec_TransactionOutputsZ {
4404 private:
4405         LDKCVec_TransactionOutputsZ self;
4406 public:
4407         CVec_TransactionOutputsZ(const CVec_TransactionOutputsZ&) = delete;
4408         CVec_TransactionOutputsZ(CVec_TransactionOutputsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); }
4409         CVec_TransactionOutputsZ(LDKCVec_TransactionOutputsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionOutputsZ)); }
4410         operator LDKCVec_TransactionOutputsZ() && { LDKCVec_TransactionOutputsZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionOutputsZ)); return res; }
4411         ~CVec_TransactionOutputsZ() { CVec_TransactionOutputsZ_free(self); }
4412         CVec_TransactionOutputsZ& operator=(CVec_TransactionOutputsZ&& o) { CVec_TransactionOutputsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); return *this; }
4413         LDKCVec_TransactionOutputsZ* operator &() { return &self; }
4414         LDKCVec_TransactionOutputsZ* operator ->() { return &self; }
4415         const LDKCVec_TransactionOutputsZ* operator &() const { return &self; }
4416         const LDKCVec_TransactionOutputsZ* operator ->() const { return &self; }
4417 };
4418 class CResult_ErrorMessageDecodeErrorZ {
4419 private:
4420         LDKCResult_ErrorMessageDecodeErrorZ self;
4421 public:
4422         CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
4423         CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
4424         CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
4425         operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
4426         ~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
4427         CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
4428         LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
4429         LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
4430         const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
4431         const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
4432 };
4433 class CResult_OpenChannelDecodeErrorZ {
4434 private:
4435         LDKCResult_OpenChannelDecodeErrorZ self;
4436 public:
4437         CResult_OpenChannelDecodeErrorZ(const CResult_OpenChannelDecodeErrorZ&) = delete;
4438         CResult_OpenChannelDecodeErrorZ(CResult_OpenChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); }
4439         CResult_OpenChannelDecodeErrorZ(LDKCResult_OpenChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); }
4440         operator LDKCResult_OpenChannelDecodeErrorZ() && { LDKCResult_OpenChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); return res; }
4441         ~CResult_OpenChannelDecodeErrorZ() { CResult_OpenChannelDecodeErrorZ_free(self); }
4442         CResult_OpenChannelDecodeErrorZ& operator=(CResult_OpenChannelDecodeErrorZ&& o) { CResult_OpenChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); return *this; }
4443         LDKCResult_OpenChannelDecodeErrorZ* operator &() { return &self; }
4444         LDKCResult_OpenChannelDecodeErrorZ* operator ->() { return &self; }
4445         const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
4446         const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
4447 };
4448 class CVec_CVec_u8ZZ {
4449 private:
4450         LDKCVec_CVec_u8ZZ self;
4451 public:
4452         CVec_CVec_u8ZZ(const CVec_CVec_u8ZZ&) = delete;
4453         CVec_CVec_u8ZZ(CVec_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_u8ZZ)); }
4454         CVec_CVec_u8ZZ(LDKCVec_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_u8ZZ)); }
4455         operator LDKCVec_CVec_u8ZZ() && { LDKCVec_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_u8ZZ)); return res; }
4456         ~CVec_CVec_u8ZZ() { CVec_CVec_u8ZZ_free(self); }
4457         CVec_CVec_u8ZZ& operator=(CVec_CVec_u8ZZ&& o) { CVec_CVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CVec_u8ZZ)); return *this; }
4458         LDKCVec_CVec_u8ZZ* operator &() { return &self; }
4459         LDKCVec_CVec_u8ZZ* operator ->() { return &self; }
4460         const LDKCVec_CVec_u8ZZ* operator &() const { return &self; }
4461         const LDKCVec_CVec_u8ZZ* operator ->() const { return &self; }
4462 };
4463 class COption_FilterZ {
4464 private:
4465         LDKCOption_FilterZ self;
4466 public:
4467         COption_FilterZ(const COption_FilterZ&) = delete;
4468         COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
4469         COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
4470         operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
4471         ~COption_FilterZ() { COption_FilterZ_free(self); }
4472         COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
4473         LDKCOption_FilterZ* operator &() { return &self; }
4474         LDKCOption_FilterZ* operator ->() { return &self; }
4475         const LDKCOption_FilterZ* operator &() const { return &self; }
4476         const LDKCOption_FilterZ* operator ->() const { return &self; }
4477 };
4478 class CResult_ProbabilisticScorerDecodeErrorZ {
4479 private:
4480         LDKCResult_ProbabilisticScorerDecodeErrorZ self;
4481 public:
4482         CResult_ProbabilisticScorerDecodeErrorZ(const CResult_ProbabilisticScorerDecodeErrorZ&) = delete;
4483         CResult_ProbabilisticScorerDecodeErrorZ(CResult_ProbabilisticScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); }
4484         CResult_ProbabilisticScorerDecodeErrorZ(LDKCResult_ProbabilisticScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); }
4485         operator LDKCResult_ProbabilisticScorerDecodeErrorZ() && { LDKCResult_ProbabilisticScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); return res; }
4486         ~CResult_ProbabilisticScorerDecodeErrorZ() { CResult_ProbabilisticScorerDecodeErrorZ_free(self); }
4487         CResult_ProbabilisticScorerDecodeErrorZ& operator=(CResult_ProbabilisticScorerDecodeErrorZ&& o) { CResult_ProbabilisticScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); return *this; }
4488         LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() { return &self; }
4489         LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() { return &self; }
4490         const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
4491         const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
4492 };
4493 class CResult_SecretKeyErrorZ {
4494 private:
4495         LDKCResult_SecretKeyErrorZ self;
4496 public:
4497         CResult_SecretKeyErrorZ(const CResult_SecretKeyErrorZ&) = delete;
4498         CResult_SecretKeyErrorZ(CResult_SecretKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SecretKeyErrorZ)); }
4499         CResult_SecretKeyErrorZ(LDKCResult_SecretKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SecretKeyErrorZ)); }
4500         operator LDKCResult_SecretKeyErrorZ() && { LDKCResult_SecretKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SecretKeyErrorZ)); return res; }
4501         ~CResult_SecretKeyErrorZ() { CResult_SecretKeyErrorZ_free(self); }
4502         CResult_SecretKeyErrorZ& operator=(CResult_SecretKeyErrorZ&& o) { CResult_SecretKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SecretKeyErrorZ)); return *this; }
4503         LDKCResult_SecretKeyErrorZ* operator &() { return &self; }
4504         LDKCResult_SecretKeyErrorZ* operator ->() { return &self; }
4505         const LDKCResult_SecretKeyErrorZ* operator &() const { return &self; }
4506         const LDKCResult_SecretKeyErrorZ* operator ->() const { return &self; }
4507 };
4508 class CResult_ShutdownScriptDecodeErrorZ {
4509 private:
4510         LDKCResult_ShutdownScriptDecodeErrorZ self;
4511 public:
4512         CResult_ShutdownScriptDecodeErrorZ(const CResult_ShutdownScriptDecodeErrorZ&) = delete;
4513         CResult_ShutdownScriptDecodeErrorZ(CResult_ShutdownScriptDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); }
4514         CResult_ShutdownScriptDecodeErrorZ(LDKCResult_ShutdownScriptDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); }
4515         operator LDKCResult_ShutdownScriptDecodeErrorZ() && { LDKCResult_ShutdownScriptDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); return res; }
4516         ~CResult_ShutdownScriptDecodeErrorZ() { CResult_ShutdownScriptDecodeErrorZ_free(self); }
4517         CResult_ShutdownScriptDecodeErrorZ& operator=(CResult_ShutdownScriptDecodeErrorZ&& o) { CResult_ShutdownScriptDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); return *this; }
4518         LDKCResult_ShutdownScriptDecodeErrorZ* operator &() { return &self; }
4519         LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() { return &self; }
4520         const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
4521         const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
4522 };
4523 class CResult_InvoiceNoneZ {
4524 private:
4525         LDKCResult_InvoiceNoneZ self;
4526 public:
4527         CResult_InvoiceNoneZ(const CResult_InvoiceNoneZ&) = delete;
4528         CResult_InvoiceNoneZ(CResult_InvoiceNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceNoneZ)); }
4529         CResult_InvoiceNoneZ(LDKCResult_InvoiceNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceNoneZ)); }
4530         operator LDKCResult_InvoiceNoneZ() && { LDKCResult_InvoiceNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceNoneZ)); return res; }
4531         ~CResult_InvoiceNoneZ() { CResult_InvoiceNoneZ_free(self); }
4532         CResult_InvoiceNoneZ& operator=(CResult_InvoiceNoneZ&& o) { CResult_InvoiceNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceNoneZ)); return *this; }
4533         LDKCResult_InvoiceNoneZ* operator &() { return &self; }
4534         LDKCResult_InvoiceNoneZ* operator ->() { return &self; }
4535         const LDKCResult_InvoiceNoneZ* operator &() const { return &self; }
4536         const LDKCResult_InvoiceNoneZ* operator ->() const { return &self; }
4537 };
4538 class CResult_TxCreationKeysDecodeErrorZ {
4539 private:
4540         LDKCResult_TxCreationKeysDecodeErrorZ self;
4541 public:
4542         CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
4543         CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
4544         CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
4545         operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
4546         ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
4547         CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
4548         LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
4549         LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
4550         const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
4551         const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
4552 };
4553 class C2Tuple_usizeTransactionZ {
4554 private:
4555         LDKC2Tuple_usizeTransactionZ self;
4556 public:
4557         C2Tuple_usizeTransactionZ(const C2Tuple_usizeTransactionZ&) = delete;
4558         C2Tuple_usizeTransactionZ(C2Tuple_usizeTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); }
4559         C2Tuple_usizeTransactionZ(LDKC2Tuple_usizeTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); }
4560         operator LDKC2Tuple_usizeTransactionZ() && { LDKC2Tuple_usizeTransactionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); return res; }
4561         ~C2Tuple_usizeTransactionZ() { C2Tuple_usizeTransactionZ_free(self); }
4562         C2Tuple_usizeTransactionZ& operator=(C2Tuple_usizeTransactionZ&& o) { C2Tuple_usizeTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); return *this; }
4563         LDKC2Tuple_usizeTransactionZ* operator &() { return &self; }
4564         LDKC2Tuple_usizeTransactionZ* operator ->() { return &self; }
4565         const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
4566         const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
4567 };
4568 class CResult_ChannelFeaturesDecodeErrorZ {
4569 private:
4570         LDKCResult_ChannelFeaturesDecodeErrorZ self;
4571 public:
4572         CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
4573         CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
4574         CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
4575         operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
4576         ~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
4577         CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
4578         LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
4579         LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
4580         const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
4581         const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
4582 };
4583 class CVec_ChannelMonitorZ {
4584 private:
4585         LDKCVec_ChannelMonitorZ self;
4586 public:
4587         CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
4588         CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
4589         CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
4590         operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
4591         ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
4592         CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
4593         LDKCVec_ChannelMonitorZ* operator &() { return &self; }
4594         LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
4595         const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
4596         const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
4597 };
4598 class CVec_TransactionZ {
4599 private:
4600         LDKCVec_TransactionZ self;
4601 public:
4602         CVec_TransactionZ(const CVec_TransactionZ&) = delete;
4603         CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
4604         CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
4605         operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
4606         ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
4607         CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
4608         LDKCVec_TransactionZ* operator &() { return &self; }
4609         LDKCVec_TransactionZ* operator ->() { return &self; }
4610         const LDKCVec_TransactionZ* operator &() const { return &self; }
4611         const LDKCVec_TransactionZ* operator ->() const { return &self; }
4612 };
4613 class CResult_UpdateFeeDecodeErrorZ {
4614 private:
4615         LDKCResult_UpdateFeeDecodeErrorZ self;
4616 public:
4617         CResult_UpdateFeeDecodeErrorZ(const CResult_UpdateFeeDecodeErrorZ&) = delete;
4618         CResult_UpdateFeeDecodeErrorZ(CResult_UpdateFeeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); }
4619         CResult_UpdateFeeDecodeErrorZ(LDKCResult_UpdateFeeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); }
4620         operator LDKCResult_UpdateFeeDecodeErrorZ() && { LDKCResult_UpdateFeeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); return res; }
4621         ~CResult_UpdateFeeDecodeErrorZ() { CResult_UpdateFeeDecodeErrorZ_free(self); }
4622         CResult_UpdateFeeDecodeErrorZ& operator=(CResult_UpdateFeeDecodeErrorZ&& o) { CResult_UpdateFeeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); return *this; }
4623         LDKCResult_UpdateFeeDecodeErrorZ* operator &() { return &self; }
4624         LDKCResult_UpdateFeeDecodeErrorZ* operator ->() { return &self; }
4625         const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
4626         const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
4627 };
4628 class CResult_RouteHopDecodeErrorZ {
4629 private:
4630         LDKCResult_RouteHopDecodeErrorZ self;
4631 public:
4632         CResult_RouteHopDecodeErrorZ(const CResult_RouteHopDecodeErrorZ&) = delete;
4633         CResult_RouteHopDecodeErrorZ(CResult_RouteHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); }
4634         CResult_RouteHopDecodeErrorZ(LDKCResult_RouteHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); }
4635         operator LDKCResult_RouteHopDecodeErrorZ() && { LDKCResult_RouteHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); return res; }
4636         ~CResult_RouteHopDecodeErrorZ() { CResult_RouteHopDecodeErrorZ_free(self); }
4637         CResult_RouteHopDecodeErrorZ& operator=(CResult_RouteHopDecodeErrorZ&& o) { CResult_RouteHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); return *this; }
4638         LDKCResult_RouteHopDecodeErrorZ* operator &() { return &self; }
4639         LDKCResult_RouteHopDecodeErrorZ* operator ->() { return &self; }
4640         const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
4641         const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
4642 };
4643 class CResult_NodeAnnouncementDecodeErrorZ {
4644 private:
4645         LDKCResult_NodeAnnouncementDecodeErrorZ self;
4646 public:
4647         CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
4648         CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
4649         CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
4650         operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
4651         ~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
4652         CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
4653         LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
4654         LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
4655         const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
4656         const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
4657 };
4658 class CResult_QueryChannelRangeDecodeErrorZ {
4659 private:
4660         LDKCResult_QueryChannelRangeDecodeErrorZ self;
4661 public:
4662         CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
4663         CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
4664         CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
4665         operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
4666         ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
4667         CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
4668         LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
4669         LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
4670         const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
4671         const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
4672 };
4673 class CVec_BalanceZ {
4674 private:
4675         LDKCVec_BalanceZ self;
4676 public:
4677         CVec_BalanceZ(const CVec_BalanceZ&) = delete;
4678         CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
4679         CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
4680         operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
4681         ~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
4682         CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
4683         LDKCVec_BalanceZ* operator &() { return &self; }
4684         LDKCVec_BalanceZ* operator ->() { return &self; }
4685         const LDKCVec_BalanceZ* operator &() const { return &self; }
4686         const LDKCVec_BalanceZ* operator ->() const { return &self; }
4687 };
4688 class CResult_HTLCOutputInCommitmentDecodeErrorZ {
4689 private:
4690         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
4691 public:
4692         CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
4693         CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
4694         CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
4695         operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
4696         ~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
4697         CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
4698         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
4699         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
4700         const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
4701         const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
4702 };
4703 class CResult_boolLightningErrorZ {
4704 private:
4705         LDKCResult_boolLightningErrorZ self;
4706 public:
4707         CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
4708         CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
4709         CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
4710         operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
4711         ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
4712         CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
4713         LDKCResult_boolLightningErrorZ* operator &() { return &self; }
4714         LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
4715         const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
4716         const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
4717 };
4718 class CResult_TxCreationKeysErrorZ {
4719 private:
4720         LDKCResult_TxCreationKeysErrorZ self;
4721 public:
4722         CResult_TxCreationKeysErrorZ(const CResult_TxCreationKeysErrorZ&) = delete;
4723         CResult_TxCreationKeysErrorZ(CResult_TxCreationKeysErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysErrorZ)); }
4724         CResult_TxCreationKeysErrorZ(LDKCResult_TxCreationKeysErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysErrorZ)); }
4725         operator LDKCResult_TxCreationKeysErrorZ() && { LDKCResult_TxCreationKeysErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysErrorZ)); return res; }
4726         ~CResult_TxCreationKeysErrorZ() { CResult_TxCreationKeysErrorZ_free(self); }
4727         CResult_TxCreationKeysErrorZ& operator=(CResult_TxCreationKeysErrorZ&& o) { CResult_TxCreationKeysErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysErrorZ)); return *this; }
4728         LDKCResult_TxCreationKeysErrorZ* operator &() { return &self; }
4729         LDKCResult_TxCreationKeysErrorZ* operator ->() { return &self; }
4730         const LDKCResult_TxCreationKeysErrorZ* operator &() const { return &self; }
4731         const LDKCResult_TxCreationKeysErrorZ* operator ->() const { return &self; }
4732 };
4733 class C2Tuple_BlockHashChannelMonitorZ {
4734 private:
4735         LDKC2Tuple_BlockHashChannelMonitorZ self;
4736 public:
4737         C2Tuple_BlockHashChannelMonitorZ(const C2Tuple_BlockHashChannelMonitorZ&) = delete;
4738         C2Tuple_BlockHashChannelMonitorZ(C2Tuple_BlockHashChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlockHashChannelMonitorZ)); }
4739         C2Tuple_BlockHashChannelMonitorZ(LDKC2Tuple_BlockHashChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlockHashChannelMonitorZ)); }
4740         operator LDKC2Tuple_BlockHashChannelMonitorZ() && { LDKC2Tuple_BlockHashChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlockHashChannelMonitorZ)); return res; }
4741         ~C2Tuple_BlockHashChannelMonitorZ() { C2Tuple_BlockHashChannelMonitorZ_free(self); }
4742         C2Tuple_BlockHashChannelMonitorZ& operator=(C2Tuple_BlockHashChannelMonitorZ&& o) { C2Tuple_BlockHashChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlockHashChannelMonitorZ)); return *this; }
4743         LDKC2Tuple_BlockHashChannelMonitorZ* operator &() { return &self; }
4744         LDKC2Tuple_BlockHashChannelMonitorZ* operator ->() { return &self; }
4745         const LDKC2Tuple_BlockHashChannelMonitorZ* operator &() const { return &self; }
4746         const LDKC2Tuple_BlockHashChannelMonitorZ* operator ->() const { return &self; }
4747 };
4748 class CResult_NodeIdDecodeErrorZ {
4749 private:
4750         LDKCResult_NodeIdDecodeErrorZ self;
4751 public:
4752         CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
4753         CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
4754         CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
4755         operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
4756         ~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
4757         CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
4758         LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
4759         LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
4760         const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
4761         const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
4762 };
4763 class CResult_ShutdownScriptInvalidShutdownScriptZ {
4764 private:
4765         LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
4766 public:
4767         CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
4768         CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
4769         CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
4770         operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
4771         ~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
4772         CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
4773         LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
4774         LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
4775         const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
4776         const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
4777 };
4778 class CResult_RecoverableSignatureNoneZ {
4779 private:
4780         LDKCResult_RecoverableSignatureNoneZ self;
4781 public:
4782         CResult_RecoverableSignatureNoneZ(const CResult_RecoverableSignatureNoneZ&) = delete;
4783         CResult_RecoverableSignatureNoneZ(CResult_RecoverableSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); }
4784         CResult_RecoverableSignatureNoneZ(LDKCResult_RecoverableSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); }
4785         operator LDKCResult_RecoverableSignatureNoneZ() && { LDKCResult_RecoverableSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); return res; }
4786         ~CResult_RecoverableSignatureNoneZ() { CResult_RecoverableSignatureNoneZ_free(self); }
4787         CResult_RecoverableSignatureNoneZ& operator=(CResult_RecoverableSignatureNoneZ&& o) { CResult_RecoverableSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); return *this; }
4788         LDKCResult_RecoverableSignatureNoneZ* operator &() { return &self; }
4789         LDKCResult_RecoverableSignatureNoneZ* operator ->() { return &self; }
4790         const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
4791         const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
4792 };
4793 class CResult_COption_NetworkUpdateZDecodeErrorZ {
4794 private:
4795         LDKCResult_COption_NetworkUpdateZDecodeErrorZ self;
4796 public:
4797         CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
4798         CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
4799         CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
4800         operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
4801         ~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
4802         CResult_COption_NetworkUpdateZDecodeErrorZ& operator=(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); return *this; }
4803         LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
4804         LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
4805         const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
4806         const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
4807 };
4808 class CResult_NodeAnnouncementInfoDecodeErrorZ {
4809 private:
4810         LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
4811 public:
4812         CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
4813         CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
4814         CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
4815         operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
4816         ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
4817         CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
4818         LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
4819         LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
4820         const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
4821         const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
4822 };
4823 class C3Tuple_RawInvoice_u832InvoiceSignatureZ {
4824 private:
4825         LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ self;
4826 public:
4827         C3Tuple_RawInvoice_u832InvoiceSignatureZ(const C3Tuple_RawInvoice_u832InvoiceSignatureZ&) = delete;
4828         C3Tuple_RawInvoice_u832InvoiceSignatureZ(C3Tuple_RawInvoice_u832InvoiceSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_RawInvoice_u832InvoiceSignatureZ)); }
4829         C3Tuple_RawInvoice_u832InvoiceSignatureZ(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ)); }
4830         operator LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ() && { LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ)); return res; }
4831         ~C3Tuple_RawInvoice_u832InvoiceSignatureZ() { C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(self); }
4832         C3Tuple_RawInvoice_u832InvoiceSignatureZ& operator=(C3Tuple_RawInvoice_u832InvoiceSignatureZ&& o) { C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_RawInvoice_u832InvoiceSignatureZ)); return *this; }
4833         LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator &() { return &self; }
4834         LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator ->() { return &self; }
4835         const LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator &() const { return &self; }
4836         const LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator ->() const { return &self; }
4837 };
4838 class CVec_UpdateFailMalformedHTLCZ {
4839 private:
4840         LDKCVec_UpdateFailMalformedHTLCZ self;
4841 public:
4842         CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
4843         CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
4844         CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
4845         operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
4846         ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
4847         CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
4848         LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
4849         LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
4850         const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
4851         const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
4852 };
4853 class CResult_FundingSignedDecodeErrorZ {
4854 private:
4855         LDKCResult_FundingSignedDecodeErrorZ self;
4856 public:
4857         CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
4858         CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
4859         CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
4860         operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
4861         ~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
4862         CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
4863         LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
4864         LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
4865         const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
4866         const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
4867 };
4868 class CResult_NetworkGraphDecodeErrorZ {
4869 private:
4870         LDKCResult_NetworkGraphDecodeErrorZ self;
4871 public:
4872         CResult_NetworkGraphDecodeErrorZ(const CResult_NetworkGraphDecodeErrorZ&) = delete;
4873         CResult_NetworkGraphDecodeErrorZ(CResult_NetworkGraphDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); }
4874         CResult_NetworkGraphDecodeErrorZ(LDKCResult_NetworkGraphDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); }
4875         operator LDKCResult_NetworkGraphDecodeErrorZ() && { LDKCResult_NetworkGraphDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); return res; }
4876         ~CResult_NetworkGraphDecodeErrorZ() { CResult_NetworkGraphDecodeErrorZ_free(self); }
4877         CResult_NetworkGraphDecodeErrorZ& operator=(CResult_NetworkGraphDecodeErrorZ&& o) { CResult_NetworkGraphDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); return *this; }
4878         LDKCResult_NetworkGraphDecodeErrorZ* operator &() { return &self; }
4879         LDKCResult_NetworkGraphDecodeErrorZ* operator ->() { return &self; }
4880         const LDKCResult_NetworkGraphDecodeErrorZ* operator &() const { return &self; }
4881         const LDKCResult_NetworkGraphDecodeErrorZ* operator ->() const { return &self; }
4882 };
4883 class CVec_RouteHopZ {
4884 private:
4885         LDKCVec_RouteHopZ self;
4886 public:
4887         CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
4888         CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
4889         CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
4890         operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
4891         ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
4892         CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
4893         LDKCVec_RouteHopZ* operator &() { return &self; }
4894         LDKCVec_RouteHopZ* operator ->() { return &self; }
4895         const LDKCVec_RouteHopZ* operator &() const { return &self; }
4896         const LDKCVec_RouteHopZ* operator ->() const { return &self; }
4897 };
4898 class CVec_C2Tuple_BlockHashChannelMonitorZZ {
4899 private:
4900         LDKCVec_C2Tuple_BlockHashChannelMonitorZZ self;
4901 public:
4902         CVec_C2Tuple_BlockHashChannelMonitorZZ(const CVec_C2Tuple_BlockHashChannelMonitorZZ&) = delete;
4903         CVec_C2Tuple_BlockHashChannelMonitorZZ(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); }
4904         CVec_C2Tuple_BlockHashChannelMonitorZZ(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); }
4905         operator LDKCVec_C2Tuple_BlockHashChannelMonitorZZ() && { LDKCVec_C2Tuple_BlockHashChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); return res; }
4906         ~CVec_C2Tuple_BlockHashChannelMonitorZZ() { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); }
4907         CVec_C2Tuple_BlockHashChannelMonitorZZ& operator=(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); return *this; }
4908         LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() { return &self; }
4909         LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() { return &self; }
4910         const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() const { return &self; }
4911         const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() const { return &self; }
4912 };
4913 class CResult_NonePaymentSendFailureZ {
4914 private:
4915         LDKCResult_NonePaymentSendFailureZ self;
4916 public:
4917         CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
4918         CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
4919         CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
4920         operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
4921         ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
4922         CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
4923         LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
4924         LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
4925         const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
4926         const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
4927 };
4928 class CResult_RouteLightningErrorZ {
4929 private:
4930         LDKCResult_RouteLightningErrorZ self;
4931 public:
4932         CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
4933         CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
4934         CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
4935         operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
4936         ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
4937         CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
4938         LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
4939         LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
4940         const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
4941         const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
4942 };
4943 class CResult_ChannelPublicKeysDecodeErrorZ {
4944 private:
4945         LDKCResult_ChannelPublicKeysDecodeErrorZ self;
4946 public:
4947         CResult_ChannelPublicKeysDecodeErrorZ(const CResult_ChannelPublicKeysDecodeErrorZ&) = delete;
4948         CResult_ChannelPublicKeysDecodeErrorZ(CResult_ChannelPublicKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); }
4949         CResult_ChannelPublicKeysDecodeErrorZ(LDKCResult_ChannelPublicKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); }
4950         operator LDKCResult_ChannelPublicKeysDecodeErrorZ() && { LDKCResult_ChannelPublicKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); return res; }
4951         ~CResult_ChannelPublicKeysDecodeErrorZ() { CResult_ChannelPublicKeysDecodeErrorZ_free(self); }
4952         CResult_ChannelPublicKeysDecodeErrorZ& operator=(CResult_ChannelPublicKeysDecodeErrorZ&& o) { CResult_ChannelPublicKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); return *this; }
4953         LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() { return &self; }
4954         LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() { return &self; }
4955         const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
4956         const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
4957 };
4958 class CVec_u8Z {
4959 private:
4960         LDKCVec_u8Z self;
4961 public:
4962         CVec_u8Z(const CVec_u8Z&) = delete;
4963         CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
4964         CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
4965         operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
4966         ~CVec_u8Z() { CVec_u8Z_free(self); }
4967         CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
4968         LDKCVec_u8Z* operator &() { return &self; }
4969         LDKCVec_u8Z* operator ->() { return &self; }
4970         const LDKCVec_u8Z* operator &() const { return &self; }
4971         const LDKCVec_u8Z* operator ->() const { return &self; }
4972 };
4973 class CResult_NodeInfoDecodeErrorZ {
4974 private:
4975         LDKCResult_NodeInfoDecodeErrorZ self;
4976 public:
4977         CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
4978         CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
4979         CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
4980         operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
4981         ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
4982         CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
4983         LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
4984         LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
4985         const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
4986         const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
4987 };
4988 class CResult_ClosingSignedDecodeErrorZ {
4989 private:
4990         LDKCResult_ClosingSignedDecodeErrorZ self;
4991 public:
4992         CResult_ClosingSignedDecodeErrorZ(const CResult_ClosingSignedDecodeErrorZ&) = delete;
4993         CResult_ClosingSignedDecodeErrorZ(CResult_ClosingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); }
4994         CResult_ClosingSignedDecodeErrorZ(LDKCResult_ClosingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); }
4995         operator LDKCResult_ClosingSignedDecodeErrorZ() && { LDKCResult_ClosingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); return res; }
4996         ~CResult_ClosingSignedDecodeErrorZ() { CResult_ClosingSignedDecodeErrorZ_free(self); }
4997         CResult_ClosingSignedDecodeErrorZ& operator=(CResult_ClosingSignedDecodeErrorZ&& o) { CResult_ClosingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); return *this; }
4998         LDKCResult_ClosingSignedDecodeErrorZ* operator &() { return &self; }
4999         LDKCResult_ClosingSignedDecodeErrorZ* operator ->() { return &self; }
5000         const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
5001         const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
5002 };
5003 class CResult_HolderCommitmentTransactionDecodeErrorZ {
5004 private:
5005         LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
5006 public:
5007         CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
5008         CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
5009         CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
5010         operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
5011         ~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
5012         CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
5013         LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
5014         LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
5015         const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
5016         const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
5017 };
5018 class CVec_CResult_NoneAPIErrorZZ {
5019 private:
5020         LDKCVec_CResult_NoneAPIErrorZZ self;
5021 public:
5022         CVec_CResult_NoneAPIErrorZZ(const CVec_CResult_NoneAPIErrorZZ&) = delete;
5023         CVec_CResult_NoneAPIErrorZZ(CVec_CResult_NoneAPIErrorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); }
5024         CVec_CResult_NoneAPIErrorZZ(LDKCVec_CResult_NoneAPIErrorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); }
5025         operator LDKCVec_CResult_NoneAPIErrorZZ() && { LDKCVec_CResult_NoneAPIErrorZZ res = self; memset(&self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); return res; }
5026         ~CVec_CResult_NoneAPIErrorZZ() { CVec_CResult_NoneAPIErrorZZ_free(self); }
5027         CVec_CResult_NoneAPIErrorZZ& operator=(CVec_CResult_NoneAPIErrorZZ&& o) { CVec_CResult_NoneAPIErrorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); return *this; }
5028         LDKCVec_CResult_NoneAPIErrorZZ* operator &() { return &self; }
5029         LDKCVec_CResult_NoneAPIErrorZZ* operator ->() { return &self; }
5030         const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
5031         const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
5032 };
5033 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
5034 private:
5035         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
5036 public:
5037         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
5038         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
5039         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
5040         operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
5041         ~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
5042         CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
5043         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
5044         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
5045         const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
5046         const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
5047 };
5048 class CResult_ChannelCounterpartyDecodeErrorZ {
5049 private:
5050         LDKCResult_ChannelCounterpartyDecodeErrorZ self;
5051 public:
5052         CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
5053         CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
5054         CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
5055         operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
5056         ~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
5057         CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
5058         LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
5059         LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
5060         const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
5061         const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
5062 };
5063 class CResult_WarningMessageDecodeErrorZ {
5064 private:
5065         LDKCResult_WarningMessageDecodeErrorZ self;
5066 public:
5067         CResult_WarningMessageDecodeErrorZ(const CResult_WarningMessageDecodeErrorZ&) = delete;
5068         CResult_WarningMessageDecodeErrorZ(CResult_WarningMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); }
5069         CResult_WarningMessageDecodeErrorZ(LDKCResult_WarningMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); }
5070         operator LDKCResult_WarningMessageDecodeErrorZ() && { LDKCResult_WarningMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); return res; }
5071         ~CResult_WarningMessageDecodeErrorZ() { CResult_WarningMessageDecodeErrorZ_free(self); }
5072         CResult_WarningMessageDecodeErrorZ& operator=(CResult_WarningMessageDecodeErrorZ&& o) { CResult_WarningMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); return *this; }
5073         LDKCResult_WarningMessageDecodeErrorZ* operator &() { return &self; }
5074         LDKCResult_WarningMessageDecodeErrorZ* operator ->() { return &self; }
5075         const LDKCResult_WarningMessageDecodeErrorZ* operator &() const { return &self; }
5076         const LDKCResult_WarningMessageDecodeErrorZ* operator ->() const { return &self; }
5077 };
5078 class CResult_SignatureNoneZ {
5079 private:
5080         LDKCResult_SignatureNoneZ self;
5081 public:
5082         CResult_SignatureNoneZ(const CResult_SignatureNoneZ&) = delete;
5083         CResult_SignatureNoneZ(CResult_SignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignatureNoneZ)); }
5084         CResult_SignatureNoneZ(LDKCResult_SignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignatureNoneZ)); }
5085         operator LDKCResult_SignatureNoneZ() && { LDKCResult_SignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SignatureNoneZ)); return res; }
5086         ~CResult_SignatureNoneZ() { CResult_SignatureNoneZ_free(self); }
5087         CResult_SignatureNoneZ& operator=(CResult_SignatureNoneZ&& o) { CResult_SignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignatureNoneZ)); return *this; }
5088         LDKCResult_SignatureNoneZ* operator &() { return &self; }
5089         LDKCResult_SignatureNoneZ* operator ->() { return &self; }
5090         const LDKCResult_SignatureNoneZ* operator &() const { return &self; }
5091         const LDKCResult_SignatureNoneZ* operator ->() const { return &self; }
5092 };
5093 class CVec_RouteHintHopZ {
5094 private:
5095         LDKCVec_RouteHintHopZ self;
5096 public:
5097         CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
5098         CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
5099         CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
5100         operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
5101         ~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
5102         CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
5103         LDKCVec_RouteHintHopZ* operator &() { return &self; }
5104         LDKCVec_RouteHintHopZ* operator ->() { return &self; }
5105         const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
5106         const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
5107 };
5108 class CResult_SecretKeyNoneZ {
5109 private:
5110         LDKCResult_SecretKeyNoneZ self;
5111 public:
5112         CResult_SecretKeyNoneZ(const CResult_SecretKeyNoneZ&) = delete;
5113         CResult_SecretKeyNoneZ(CResult_SecretKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SecretKeyNoneZ)); }
5114         CResult_SecretKeyNoneZ(LDKCResult_SecretKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SecretKeyNoneZ)); }
5115         operator LDKCResult_SecretKeyNoneZ() && { LDKCResult_SecretKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SecretKeyNoneZ)); return res; }
5116         ~CResult_SecretKeyNoneZ() { CResult_SecretKeyNoneZ_free(self); }
5117         CResult_SecretKeyNoneZ& operator=(CResult_SecretKeyNoneZ&& o) { CResult_SecretKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SecretKeyNoneZ)); return *this; }
5118         LDKCResult_SecretKeyNoneZ* operator &() { return &self; }
5119         LDKCResult_SecretKeyNoneZ* operator ->() { return &self; }
5120         const LDKCResult_SecretKeyNoneZ* operator &() const { return &self; }
5121         const LDKCResult_SecretKeyNoneZ* operator ->() const { return &self; }
5122 };
5123 class CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ {
5124 private:
5125         LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ self;
5126 public:
5127         CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(const CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&) = delete;
5128         CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); }
5129         CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); }
5130         operator LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ() && { LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); return res; }
5131         ~CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ() { CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(self); }
5132         CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ& operator=(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& o) { CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); return *this; }
5133         LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator &() { return &self; }
5134         LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator ->() { return &self; }
5135         const LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator &() const { return &self; }
5136         const LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator ->() const { return &self; }
5137 };
5138 class C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
5139 private:
5140         LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ self;
5141 public:
5142         C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ(const C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&) = delete;
5143         C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); }
5144         C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); }
5145         operator LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ() && { LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); return res; }
5146         ~C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ() { C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(self); }
5147         C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ& operator=(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&& o) { C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); return *this; }
5148         LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator &() { return &self; }
5149         LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator ->() { return &self; }
5150         const LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
5151         const LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
5152 };
5153 class CResult_PaymentParametersDecodeErrorZ {
5154 private:
5155         LDKCResult_PaymentParametersDecodeErrorZ self;
5156 public:
5157         CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
5158         CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
5159         CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
5160         operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
5161         ~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
5162         CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
5163         LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
5164         LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
5165         const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
5166         const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
5167 };
5168 class CResult_InitDecodeErrorZ {
5169 private:
5170         LDKCResult_InitDecodeErrorZ self;
5171 public:
5172         CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
5173         CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
5174         CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
5175         operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
5176         ~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
5177         CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
5178         LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
5179         LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
5180         const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
5181         const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
5182 };
5183 class CResult_OutPointDecodeErrorZ {
5184 private:
5185         LDKCResult_OutPointDecodeErrorZ self;
5186 public:
5187         CResult_OutPointDecodeErrorZ(const CResult_OutPointDecodeErrorZ&) = delete;
5188         CResult_OutPointDecodeErrorZ(CResult_OutPointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); }
5189         CResult_OutPointDecodeErrorZ(LDKCResult_OutPointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); }
5190         operator LDKCResult_OutPointDecodeErrorZ() && { LDKCResult_OutPointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); return res; }
5191         ~CResult_OutPointDecodeErrorZ() { CResult_OutPointDecodeErrorZ_free(self); }
5192         CResult_OutPointDecodeErrorZ& operator=(CResult_OutPointDecodeErrorZ&& o) { CResult_OutPointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); return *this; }
5193         LDKCResult_OutPointDecodeErrorZ* operator &() { return &self; }
5194         LDKCResult_OutPointDecodeErrorZ* operator ->() { return &self; }
5195         const LDKCResult_OutPointDecodeErrorZ* operator &() const { return &self; }
5196         const LDKCResult_OutPointDecodeErrorZ* operator ->() const { return &self; }
5197 };
5198 class CVec_ChannelDetailsZ {
5199 private:
5200         LDKCVec_ChannelDetailsZ self;
5201 public:
5202         CVec_ChannelDetailsZ(const CVec_ChannelDetailsZ&) = delete;
5203         CVec_ChannelDetailsZ(CVec_ChannelDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); }
5204         CVec_ChannelDetailsZ(LDKCVec_ChannelDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelDetailsZ)); }
5205         operator LDKCVec_ChannelDetailsZ() && { LDKCVec_ChannelDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelDetailsZ)); return res; }
5206         ~CVec_ChannelDetailsZ() { CVec_ChannelDetailsZ_free(self); }
5207         CVec_ChannelDetailsZ& operator=(CVec_ChannelDetailsZ&& o) { CVec_ChannelDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); return *this; }
5208         LDKCVec_ChannelDetailsZ* operator &() { return &self; }
5209         LDKCVec_ChannelDetailsZ* operator ->() { return &self; }
5210         const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
5211         const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
5212 };
5213 class CResult_SignDecodeErrorZ {
5214 private:
5215         LDKCResult_SignDecodeErrorZ self;
5216 public:
5217         CResult_SignDecodeErrorZ(const CResult_SignDecodeErrorZ&) = delete;
5218         CResult_SignDecodeErrorZ(CResult_SignDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignDecodeErrorZ)); }
5219         CResult_SignDecodeErrorZ(LDKCResult_SignDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignDecodeErrorZ)); }
5220         operator LDKCResult_SignDecodeErrorZ() && { LDKCResult_SignDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignDecodeErrorZ)); return res; }
5221         ~CResult_SignDecodeErrorZ() { CResult_SignDecodeErrorZ_free(self); }
5222         CResult_SignDecodeErrorZ& operator=(CResult_SignDecodeErrorZ&& o) { CResult_SignDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignDecodeErrorZ)); return *this; }
5223         LDKCResult_SignDecodeErrorZ* operator &() { return &self; }
5224         LDKCResult_SignDecodeErrorZ* operator ->() { return &self; }
5225         const LDKCResult_SignDecodeErrorZ* operator &() const { return &self; }
5226         const LDKCResult_SignDecodeErrorZ* operator ->() const { return &self; }
5227 };
5228 class CVec_MessageSendEventZ {
5229 private:
5230         LDKCVec_MessageSendEventZ self;
5231 public:
5232         CVec_MessageSendEventZ(const CVec_MessageSendEventZ&) = delete;
5233         CVec_MessageSendEventZ(CVec_MessageSendEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageSendEventZ)); }
5234         CVec_MessageSendEventZ(LDKCVec_MessageSendEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageSendEventZ)); }
5235         operator LDKCVec_MessageSendEventZ() && { LDKCVec_MessageSendEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageSendEventZ)); return res; }
5236         ~CVec_MessageSendEventZ() { CVec_MessageSendEventZ_free(self); }
5237         CVec_MessageSendEventZ& operator=(CVec_MessageSendEventZ&& o) { CVec_MessageSendEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MessageSendEventZ)); return *this; }
5238         LDKCVec_MessageSendEventZ* operator &() { return &self; }
5239         LDKCVec_MessageSendEventZ* operator ->() { return &self; }
5240         const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
5241         const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
5242 };
5243 class C2Tuple_OutPointScriptZ {
5244 private:
5245         LDKC2Tuple_OutPointScriptZ self;
5246 public:
5247         C2Tuple_OutPointScriptZ(const C2Tuple_OutPointScriptZ&) = delete;
5248         C2Tuple_OutPointScriptZ(C2Tuple_OutPointScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointScriptZ)); }
5249         C2Tuple_OutPointScriptZ(LDKC2Tuple_OutPointScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointScriptZ)); }
5250         operator LDKC2Tuple_OutPointScriptZ() && { LDKC2Tuple_OutPointScriptZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointScriptZ)); return res; }
5251         ~C2Tuple_OutPointScriptZ() { C2Tuple_OutPointScriptZ_free(self); }
5252         C2Tuple_OutPointScriptZ& operator=(C2Tuple_OutPointScriptZ&& o) { C2Tuple_OutPointScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointScriptZ)); return *this; }
5253         LDKC2Tuple_OutPointScriptZ* operator &() { return &self; }
5254         LDKC2Tuple_OutPointScriptZ* operator ->() { return &self; }
5255         const LDKC2Tuple_OutPointScriptZ* operator &() const { return &self; }
5256         const LDKC2Tuple_OutPointScriptZ* operator ->() const { return &self; }
5257 };
5258 class CResult_RouteHintHopDecodeErrorZ {
5259 private:
5260         LDKCResult_RouteHintHopDecodeErrorZ self;
5261 public:
5262         CResult_RouteHintHopDecodeErrorZ(const CResult_RouteHintHopDecodeErrorZ&) = delete;
5263         CResult_RouteHintHopDecodeErrorZ(CResult_RouteHintHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); }
5264         CResult_RouteHintHopDecodeErrorZ(LDKCResult_RouteHintHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); }
5265         operator LDKCResult_RouteHintHopDecodeErrorZ() && { LDKCResult_RouteHintHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); return res; }
5266         ~CResult_RouteHintHopDecodeErrorZ() { CResult_RouteHintHopDecodeErrorZ_free(self); }
5267         CResult_RouteHintHopDecodeErrorZ& operator=(CResult_RouteHintHopDecodeErrorZ&& o) { CResult_RouteHintHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); return *this; }
5268         LDKCResult_RouteHintHopDecodeErrorZ* operator &() { return &self; }
5269         LDKCResult_RouteHintHopDecodeErrorZ* operator ->() { return &self; }
5270         const LDKCResult_RouteHintHopDecodeErrorZ* operator &() const { return &self; }
5271         const LDKCResult_RouteHintHopDecodeErrorZ* operator ->() const { return &self; }
5272 };
5273 class CResult_C2Tuple_SignatureSignatureZNoneZ {
5274 private:
5275         LDKCResult_C2Tuple_SignatureSignatureZNoneZ self;
5276 public:
5277         CResult_C2Tuple_SignatureSignatureZNoneZ(const CResult_C2Tuple_SignatureSignatureZNoneZ&) = delete;
5278         CResult_C2Tuple_SignatureSignatureZNoneZ(CResult_C2Tuple_SignatureSignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_SignatureSignatureZNoneZ)); }
5279         CResult_C2Tuple_SignatureSignatureZNoneZ(LDKCResult_C2Tuple_SignatureSignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ)); }
5280         operator LDKCResult_C2Tuple_SignatureSignatureZNoneZ() && { LDKCResult_C2Tuple_SignatureSignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ)); return res; }
5281         ~CResult_C2Tuple_SignatureSignatureZNoneZ() { CResult_C2Tuple_SignatureSignatureZNoneZ_free(self); }
5282         CResult_C2Tuple_SignatureSignatureZNoneZ& operator=(CResult_C2Tuple_SignatureSignatureZNoneZ&& o) { CResult_C2Tuple_SignatureSignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_SignatureSignatureZNoneZ)); return *this; }
5283         LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator &() { return &self; }
5284         LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator ->() { return &self; }
5285         const LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator &() const { return &self; }
5286         const LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator ->() const { return &self; }
5287 };
5288 class CVec_NodeAnnouncementZ {
5289 private:
5290         LDKCVec_NodeAnnouncementZ self;
5291 public:
5292         CVec_NodeAnnouncementZ(const CVec_NodeAnnouncementZ&) = delete;
5293         CVec_NodeAnnouncementZ(CVec_NodeAnnouncementZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeAnnouncementZ)); }
5294         CVec_NodeAnnouncementZ(LDKCVec_NodeAnnouncementZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeAnnouncementZ)); }
5295         operator LDKCVec_NodeAnnouncementZ() && { LDKCVec_NodeAnnouncementZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeAnnouncementZ)); return res; }
5296         ~CVec_NodeAnnouncementZ() { CVec_NodeAnnouncementZ_free(self); }
5297         CVec_NodeAnnouncementZ& operator=(CVec_NodeAnnouncementZ&& o) { CVec_NodeAnnouncementZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeAnnouncementZ)); return *this; }
5298         LDKCVec_NodeAnnouncementZ* operator &() { return &self; }
5299         LDKCVec_NodeAnnouncementZ* operator ->() { return &self; }
5300         const LDKCVec_NodeAnnouncementZ* operator &() const { return &self; }
5301         const LDKCVec_NodeAnnouncementZ* operator ->() const { return &self; }
5302 };
5303 class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
5304 private:
5305         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
5306 public:
5307         CResult_UpdateFailMalformedHTLCDecodeErrorZ(const CResult_UpdateFailMalformedHTLCDecodeErrorZ&) = delete;
5308         CResult_UpdateFailMalformedHTLCDecodeErrorZ(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
5309         CResult_UpdateFailMalformedHTLCDecodeErrorZ(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
5310         operator LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ() && { LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); return res; }
5311         ~CResult_UpdateFailMalformedHTLCDecodeErrorZ() { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); }
5312         CResult_UpdateFailMalformedHTLCDecodeErrorZ& operator=(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); return *this; }
5313         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() { return &self; }
5314         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() { return &self; }
5315         const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
5316         const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
5317 };
5318 class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
5319 private:
5320         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
5321 public:
5322         CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
5323         CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
5324         CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
5325         operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
5326         ~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
5327         CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
5328         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
5329         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
5330         const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
5331         const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
5332 };
5333 class CVec_TxidZ {
5334 private:
5335         LDKCVec_TxidZ self;
5336 public:
5337         CVec_TxidZ(const CVec_TxidZ&) = delete;
5338         CVec_TxidZ(CVec_TxidZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxidZ)); }
5339         CVec_TxidZ(LDKCVec_TxidZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxidZ)); }
5340         operator LDKCVec_TxidZ() && { LDKCVec_TxidZ res = self; memset(&self, 0, sizeof(LDKCVec_TxidZ)); return res; }
5341         ~CVec_TxidZ() { CVec_TxidZ_free(self); }
5342         CVec_TxidZ& operator=(CVec_TxidZ&& o) { CVec_TxidZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxidZ)); return *this; }
5343         LDKCVec_TxidZ* operator &() { return &self; }
5344         LDKCVec_TxidZ* operator ->() { return &self; }
5345         const LDKCVec_TxidZ* operator &() const { return &self; }
5346         const LDKCVec_TxidZ* operator ->() const { return &self; }
5347 };
5348 class COption_AccessZ {
5349 private:
5350         LDKCOption_AccessZ self;
5351 public:
5352         COption_AccessZ(const COption_AccessZ&) = delete;
5353         COption_AccessZ(COption_AccessZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_AccessZ)); }
5354         COption_AccessZ(LDKCOption_AccessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_AccessZ)); }
5355         operator LDKCOption_AccessZ() && { LDKCOption_AccessZ res = self; memset(&self, 0, sizeof(LDKCOption_AccessZ)); return res; }
5356         ~COption_AccessZ() { COption_AccessZ_free(self); }
5357         COption_AccessZ& operator=(COption_AccessZ&& o) { COption_AccessZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_AccessZ)); return *this; }
5358         LDKCOption_AccessZ* operator &() { return &self; }
5359         LDKCOption_AccessZ* operator ->() { return &self; }
5360         const LDKCOption_AccessZ* operator &() const { return &self; }
5361         const LDKCOption_AccessZ* operator ->() const { return &self; }
5362 };
5363 class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
5364 private:
5365         LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ self;
5366 public:
5367         CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(const CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&) = delete;
5368         CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
5369         CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
5370         operator LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() && { LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return res; }
5371         ~CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); }
5372         CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ& operator=(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return *this; }
5373         LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() { return &self; }
5374         LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() { return &self; }
5375         const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() const { return &self; }
5376         const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() const { return &self; }
5377 };
5378 class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
5379 private:
5380         LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ self;
5381 public:
5382         CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&) = delete;
5383         CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
5384         CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
5385         operator LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return res; }
5386         ~CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); }
5387         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; }
5388         LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() { return &self; }
5389         LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() { return &self; }
5390         const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() const { return &self; }
5391         const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
5392 };
5393 class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
5394 private:
5395         LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
5396 public:
5397         CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
5398         CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
5399         CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
5400         operator LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
5401         ~CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
5402         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; }
5403         LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
5404         LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
5405         const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
5406         const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
5407 };
5408 class CResult_CVec_CVec_u8ZZNoneZ {
5409 private:
5410         LDKCResult_CVec_CVec_u8ZZNoneZ self;
5411 public:
5412         CResult_CVec_CVec_u8ZZNoneZ(const CResult_CVec_CVec_u8ZZNoneZ&) = delete;
5413         CResult_CVec_CVec_u8ZZNoneZ(CResult_CVec_CVec_u8ZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); }
5414         CResult_CVec_CVec_u8ZZNoneZ(LDKCResult_CVec_CVec_u8ZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); }
5415         operator LDKCResult_CVec_CVec_u8ZZNoneZ() && { LDKCResult_CVec_CVec_u8ZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); return res; }
5416         ~CResult_CVec_CVec_u8ZZNoneZ() { CResult_CVec_CVec_u8ZZNoneZ_free(self); }
5417         CResult_CVec_CVec_u8ZZNoneZ& operator=(CResult_CVec_CVec_u8ZZNoneZ&& o) { CResult_CVec_CVec_u8ZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); return *this; }
5418         LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() { return &self; }
5419         LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() { return &self; }
5420         const LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() const { return &self; }
5421         const LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() const { return &self; }
5422 };
5423 class C2Tuple_SignatureSignatureZ {
5424 private:
5425         LDKC2Tuple_SignatureSignatureZ self;
5426 public:
5427         C2Tuple_SignatureSignatureZ(const C2Tuple_SignatureSignatureZ&) = delete;
5428         C2Tuple_SignatureSignatureZ(C2Tuple_SignatureSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureSignatureZ)); }
5429         C2Tuple_SignatureSignatureZ(LDKC2Tuple_SignatureSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureSignatureZ)); }
5430         operator LDKC2Tuple_SignatureSignatureZ() && { LDKC2Tuple_SignatureSignatureZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureSignatureZ)); return res; }
5431         ~C2Tuple_SignatureSignatureZ() { C2Tuple_SignatureSignatureZ_free(self); }
5432         C2Tuple_SignatureSignatureZ& operator=(C2Tuple_SignatureSignatureZ&& o) { C2Tuple_SignatureSignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_SignatureSignatureZ)); return *this; }
5433         LDKC2Tuple_SignatureSignatureZ* operator &() { return &self; }
5434         LDKC2Tuple_SignatureSignatureZ* operator ->() { return &self; }
5435         const LDKC2Tuple_SignatureSignatureZ* operator &() const { return &self; }
5436         const LDKC2Tuple_SignatureSignatureZ* operator ->() const { return &self; }
5437 };
5438 class C2Tuple_PaymentHashPaymentSecretZ {
5439 private:
5440         LDKC2Tuple_PaymentHashPaymentSecretZ self;
5441 public:
5442         C2Tuple_PaymentHashPaymentSecretZ(const C2Tuple_PaymentHashPaymentSecretZ&) = delete;
5443         C2Tuple_PaymentHashPaymentSecretZ(C2Tuple_PaymentHashPaymentSecretZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentSecretZ)); }
5444         C2Tuple_PaymentHashPaymentSecretZ(LDKC2Tuple_PaymentHashPaymentSecretZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ)); }
5445         operator LDKC2Tuple_PaymentHashPaymentSecretZ() && { LDKC2Tuple_PaymentHashPaymentSecretZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ)); return res; }
5446         ~C2Tuple_PaymentHashPaymentSecretZ() { C2Tuple_PaymentHashPaymentSecretZ_free(self); }
5447         C2Tuple_PaymentHashPaymentSecretZ& operator=(C2Tuple_PaymentHashPaymentSecretZ&& o) { C2Tuple_PaymentHashPaymentSecretZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentSecretZ)); return *this; }
5448         LDKC2Tuple_PaymentHashPaymentSecretZ* operator &() { return &self; }
5449         LDKC2Tuple_PaymentHashPaymentSecretZ* operator ->() { return &self; }
5450         const LDKC2Tuple_PaymentHashPaymentSecretZ* operator &() const { return &self; }
5451         const LDKC2Tuple_PaymentHashPaymentSecretZ* operator ->() const { return &self; }
5452 };
5453 class C2Tuple_BlockHashChannelManagerZ {
5454 private:
5455         LDKC2Tuple_BlockHashChannelManagerZ self;
5456 public:
5457         C2Tuple_BlockHashChannelManagerZ(const C2Tuple_BlockHashChannelManagerZ&) = delete;
5458         C2Tuple_BlockHashChannelManagerZ(C2Tuple_BlockHashChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlockHashChannelManagerZ)); }
5459         C2Tuple_BlockHashChannelManagerZ(LDKC2Tuple_BlockHashChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlockHashChannelManagerZ)); }
5460         operator LDKC2Tuple_BlockHashChannelManagerZ() && { LDKC2Tuple_BlockHashChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlockHashChannelManagerZ)); return res; }
5461         ~C2Tuple_BlockHashChannelManagerZ() { C2Tuple_BlockHashChannelManagerZ_free(self); }
5462         C2Tuple_BlockHashChannelManagerZ& operator=(C2Tuple_BlockHashChannelManagerZ&& o) { C2Tuple_BlockHashChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlockHashChannelManagerZ)); return *this; }
5463         LDKC2Tuple_BlockHashChannelManagerZ* operator &() { return &self; }
5464         LDKC2Tuple_BlockHashChannelManagerZ* operator ->() { return &self; }
5465         const LDKC2Tuple_BlockHashChannelManagerZ* operator &() const { return &self; }
5466         const LDKC2Tuple_BlockHashChannelManagerZ* operator ->() const { return &self; }
5467 };
5468 class CResult_ChannelTransactionParametersDecodeErrorZ {
5469 private:
5470         LDKCResult_ChannelTransactionParametersDecodeErrorZ self;
5471 public:
5472         CResult_ChannelTransactionParametersDecodeErrorZ(const CResult_ChannelTransactionParametersDecodeErrorZ&) = delete;
5473         CResult_ChannelTransactionParametersDecodeErrorZ(CResult_ChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); }
5474         CResult_ChannelTransactionParametersDecodeErrorZ(LDKCResult_ChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); }
5475         operator LDKCResult_ChannelTransactionParametersDecodeErrorZ() && { LDKCResult_ChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); return res; }
5476         ~CResult_ChannelTransactionParametersDecodeErrorZ() { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); }
5477         CResult_ChannelTransactionParametersDecodeErrorZ& operator=(CResult_ChannelTransactionParametersDecodeErrorZ&& o) { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); return *this; }
5478         LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
5479         LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
5480         const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
5481         const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
5482 };
5483 class CResult_AcceptChannelDecodeErrorZ {
5484 private:
5485         LDKCResult_AcceptChannelDecodeErrorZ self;
5486 public:
5487         CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
5488         CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
5489         CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
5490         operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
5491         ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
5492         CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
5493         LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
5494         LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
5495         const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
5496         const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
5497 };
5498 class CVec_SignatureZ {
5499 private:
5500         LDKCVec_SignatureZ self;
5501 public:
5502         CVec_SignatureZ(const CVec_SignatureZ&) = delete;
5503         CVec_SignatureZ(CVec_SignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SignatureZ)); }
5504         CVec_SignatureZ(LDKCVec_SignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SignatureZ)); }
5505         operator LDKCVec_SignatureZ() && { LDKCVec_SignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_SignatureZ)); return res; }
5506         ~CVec_SignatureZ() { CVec_SignatureZ_free(self); }
5507         CVec_SignatureZ& operator=(CVec_SignatureZ&& o) { CVec_SignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SignatureZ)); return *this; }
5508         LDKCVec_SignatureZ* operator &() { return &self; }
5509         LDKCVec_SignatureZ* operator ->() { return &self; }
5510         const LDKCVec_SignatureZ* operator &() const { return &self; }
5511         const LDKCVec_SignatureZ* operator ->() const { return &self; }
5512 };
5513 class CVec_u64Z {
5514 private:
5515         LDKCVec_u64Z self;
5516 public:
5517         CVec_u64Z(const CVec_u64Z&) = delete;
5518         CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); }
5519         CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); }
5520         operator LDKCVec_u64Z() && { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; }
5521         ~CVec_u64Z() { CVec_u64Z_free(self); }
5522         CVec_u64Z& operator=(CVec_u64Z&& o) { CVec_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u64Z)); return *this; }
5523         LDKCVec_u64Z* operator &() { return &self; }
5524         LDKCVec_u64Z* operator ->() { return &self; }
5525         const LDKCVec_u64Z* operator &() const { return &self; }
5526         const LDKCVec_u64Z* operator ->() const { return &self; }
5527 };
5528 class CResult_ScorerDecodeErrorZ {
5529 private:
5530         LDKCResult_ScorerDecodeErrorZ self;
5531 public:
5532         CResult_ScorerDecodeErrorZ(const CResult_ScorerDecodeErrorZ&) = delete;
5533         CResult_ScorerDecodeErrorZ(CResult_ScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ScorerDecodeErrorZ)); }
5534         CResult_ScorerDecodeErrorZ(LDKCResult_ScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ScorerDecodeErrorZ)); }
5535         operator LDKCResult_ScorerDecodeErrorZ() && { LDKCResult_ScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ScorerDecodeErrorZ)); return res; }
5536         ~CResult_ScorerDecodeErrorZ() { CResult_ScorerDecodeErrorZ_free(self); }
5537         CResult_ScorerDecodeErrorZ& operator=(CResult_ScorerDecodeErrorZ&& o) { CResult_ScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ScorerDecodeErrorZ)); return *this; }
5538         LDKCResult_ScorerDecodeErrorZ* operator &() { return &self; }
5539         LDKCResult_ScorerDecodeErrorZ* operator ->() { return &self; }
5540         const LDKCResult_ScorerDecodeErrorZ* operator &() const { return &self; }
5541         const LDKCResult_ScorerDecodeErrorZ* operator ->() const { return &self; }
5542 };
5543 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
5544 private:
5545         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
5546 public:
5547         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(const CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&) = delete;
5548         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
5549         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
5550         operator LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return res; }
5551         ~CResult_DelayedPaymentOutputDescriptorDecodeErrorZ() { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); }
5552         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return *this; }
5553         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
5554         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
5555         const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
5556         const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
5557 };
5558 class C2Tuple_PaymentHashPaymentIdZ {
5559 private:
5560         LDKC2Tuple_PaymentHashPaymentIdZ self;
5561 public:
5562         C2Tuple_PaymentHashPaymentIdZ(const C2Tuple_PaymentHashPaymentIdZ&) = delete;
5563         C2Tuple_PaymentHashPaymentIdZ(C2Tuple_PaymentHashPaymentIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentIdZ)); }
5564         C2Tuple_PaymentHashPaymentIdZ(LDKC2Tuple_PaymentHashPaymentIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentIdZ)); }
5565         operator LDKC2Tuple_PaymentHashPaymentIdZ() && { LDKC2Tuple_PaymentHashPaymentIdZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentIdZ)); return res; }
5566         ~C2Tuple_PaymentHashPaymentIdZ() { C2Tuple_PaymentHashPaymentIdZ_free(self); }
5567         C2Tuple_PaymentHashPaymentIdZ& operator=(C2Tuple_PaymentHashPaymentIdZ&& o) { C2Tuple_PaymentHashPaymentIdZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentIdZ)); return *this; }
5568         LDKC2Tuple_PaymentHashPaymentIdZ* operator &() { return &self; }
5569         LDKC2Tuple_PaymentHashPaymentIdZ* operator ->() { return &self; }
5570         const LDKC2Tuple_PaymentHashPaymentIdZ* operator &() const { return &self; }
5571         const LDKC2Tuple_PaymentHashPaymentIdZ* operator ->() const { return &self; }
5572 };
5573 class CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ {
5574 private:
5575         LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ self;
5576 public:
5577         CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(const CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&) = delete;
5578         CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); }
5579         CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); }
5580         operator LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ() && { LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); return res; }
5581         ~CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ() { CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(self); }
5582         CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ& operator=(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& o) { CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); return *this; }
5583         LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator &() { return &self; }
5584         LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator ->() { return &self; }
5585         const LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator &() const { return &self; }
5586         const LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator ->() const { return &self; }
5587 };
5588 class CResult_NoneErrorZ {
5589 private:
5590         LDKCResult_NoneErrorZ self;
5591 public:
5592         CResult_NoneErrorZ(const CResult_NoneErrorZ&) = delete;
5593         CResult_NoneErrorZ(CResult_NoneErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneErrorZ)); }
5594         CResult_NoneErrorZ(LDKCResult_NoneErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneErrorZ)); }
5595         operator LDKCResult_NoneErrorZ() && { LDKCResult_NoneErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneErrorZ)); return res; }
5596         ~CResult_NoneErrorZ() { CResult_NoneErrorZ_free(self); }
5597         CResult_NoneErrorZ& operator=(CResult_NoneErrorZ&& o) { CResult_NoneErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneErrorZ)); return *this; }
5598         LDKCResult_NoneErrorZ* operator &() { return &self; }
5599         LDKCResult_NoneErrorZ* operator ->() { return &self; }
5600         const LDKCResult_NoneErrorZ* operator &() const { return &self; }
5601         const LDKCResult_NoneErrorZ* operator ->() const { return &self; }
5602 };
5603 class CResult_StringErrorZ {
5604 private:
5605         LDKCResult_StringErrorZ self;
5606 public:
5607         CResult_StringErrorZ(const CResult_StringErrorZ&) = delete;
5608         CResult_StringErrorZ(CResult_StringErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StringErrorZ)); }
5609         CResult_StringErrorZ(LDKCResult_StringErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StringErrorZ)); }
5610         operator LDKCResult_StringErrorZ() && { LDKCResult_StringErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StringErrorZ)); return res; }
5611         ~CResult_StringErrorZ() { CResult_StringErrorZ_free(self); }
5612         CResult_StringErrorZ& operator=(CResult_StringErrorZ&& o) { CResult_StringErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StringErrorZ)); return *this; }
5613         LDKCResult_StringErrorZ* operator &() { return &self; }
5614         LDKCResult_StringErrorZ* operator ->() { return &self; }
5615         const LDKCResult_StringErrorZ* operator &() const { return &self; }
5616         const LDKCResult_StringErrorZ* operator ->() const { return &self; }
5617 };
5618 class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
5619 private:
5620         LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ self;
5621 public:
5622         C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(const C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&) = delete;
5623         C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); }
5624         C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); }
5625         operator LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ() && { LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); return res; }
5626         ~C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ() { C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(self); }
5627         C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ& operator=(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& o) { C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); return *this; }
5628         LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator &() { return &self; }
5629         LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator ->() { return &self; }
5630         const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator &() const { return &self; }
5631         const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator ->() const { return &self; }
5632 };
5633 class CResult_PongDecodeErrorZ {
5634 private:
5635         LDKCResult_PongDecodeErrorZ self;
5636 public:
5637         CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
5638         CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
5639         CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
5640         operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
5641         ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
5642         CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
5643         LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
5644         LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
5645         const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
5646         const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
5647 };
5648 class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ {
5649 private:
5650         LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ self;
5651 public:
5652         CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ(const CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&) = delete;
5653         CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); }
5654         CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); }
5655         operator LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ() && { LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); return res; }
5656         ~CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ() { CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(self); }
5657         CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ& operator=(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&& o) { CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); return *this; }
5658         LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator &() { return &self; }
5659         LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator ->() { return &self; }
5660         const LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator &() const { return &self; }
5661         const LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator ->() const { return &self; }
5662 };
5663 class COption_EventZ {
5664 private:
5665         LDKCOption_EventZ self;
5666 public:
5667         COption_EventZ(const COption_EventZ&) = delete;
5668         COption_EventZ(COption_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_EventZ)); }
5669         COption_EventZ(LDKCOption_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_EventZ)); }
5670         operator LDKCOption_EventZ() && { LDKCOption_EventZ res = self; memset(&self, 0, sizeof(LDKCOption_EventZ)); return res; }
5671         ~COption_EventZ() { COption_EventZ_free(self); }
5672         COption_EventZ& operator=(COption_EventZ&& o) { COption_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_EventZ)); return *this; }
5673         LDKCOption_EventZ* operator &() { return &self; }
5674         LDKCOption_EventZ* operator ->() { return &self; }
5675         const LDKCOption_EventZ* operator &() const { return &self; }
5676         const LDKCOption_EventZ* operator ->() const { return &self; }
5677 };
5678 class CResult_ChannelTypeFeaturesDecodeErrorZ {
5679 private:
5680         LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
5681 public:
5682         CResult_ChannelTypeFeaturesDecodeErrorZ(const CResult_ChannelTypeFeaturesDecodeErrorZ&) = delete;
5683         CResult_ChannelTypeFeaturesDecodeErrorZ(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); }
5684         CResult_ChannelTypeFeaturesDecodeErrorZ(LDKCResult_ChannelTypeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); }
5685         operator LDKCResult_ChannelTypeFeaturesDecodeErrorZ() && { LDKCResult_ChannelTypeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); return res; }
5686         ~CResult_ChannelTypeFeaturesDecodeErrorZ() { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); }
5687         CResult_ChannelTypeFeaturesDecodeErrorZ& operator=(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); return *this; }
5688         LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() { return &self; }
5689         LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() { return &self; }
5690         const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() const { return &self; }
5691         const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() const { return &self; }
5692 };
5693 class CVec_RouteHintZ {
5694 private:
5695         LDKCVec_RouteHintZ self;
5696 public:
5697         CVec_RouteHintZ(const CVec_RouteHintZ&) = delete;
5698         CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); }
5699         CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); }
5700         operator LDKCVec_RouteHintZ() && { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; }
5701         ~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); }
5702         CVec_RouteHintZ& operator=(CVec_RouteHintZ&& o) { CVec_RouteHintZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintZ)); return *this; }
5703         LDKCVec_RouteHintZ* operator &() { return &self; }
5704         LDKCVec_RouteHintZ* operator ->() { return &self; }
5705         const LDKCVec_RouteHintZ* operator &() const { return &self; }
5706         const LDKCVec_RouteHintZ* operator ->() const { return &self; }
5707 };
5708 class COption_u16Z {
5709 private:
5710         LDKCOption_u16Z self;
5711 public:
5712         COption_u16Z(const COption_u16Z&) = delete;
5713         COption_u16Z(COption_u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u16Z)); }
5714         COption_u16Z(LDKCOption_u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u16Z)); }
5715         operator LDKCOption_u16Z() && { LDKCOption_u16Z res = self; memset(&self, 0, sizeof(LDKCOption_u16Z)); return res; }
5716         ~COption_u16Z() { COption_u16Z_free(self); }
5717         COption_u16Z& operator=(COption_u16Z&& o) { COption_u16Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u16Z)); return *this; }
5718         LDKCOption_u16Z* operator &() { return &self; }
5719         LDKCOption_u16Z* operator ->() { return &self; }
5720         const LDKCOption_u16Z* operator &() const { return &self; }
5721         const LDKCOption_u16Z* operator ->() const { return &self; }
5722 };
5723 class CVec_CVec_RouteHopZZ {
5724 private:
5725         LDKCVec_CVec_RouteHopZZ self;
5726 public:
5727         CVec_CVec_RouteHopZZ(const CVec_CVec_RouteHopZZ&) = delete;
5728         CVec_CVec_RouteHopZZ(CVec_CVec_RouteHopZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); }
5729         CVec_CVec_RouteHopZZ(LDKCVec_CVec_RouteHopZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); }
5730         operator LDKCVec_CVec_RouteHopZZ() && { LDKCVec_CVec_RouteHopZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); return res; }
5731         ~CVec_CVec_RouteHopZZ() { CVec_CVec_RouteHopZZ_free(self); }
5732         CVec_CVec_RouteHopZZ& operator=(CVec_CVec_RouteHopZZ&& o) { CVec_CVec_RouteHopZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); return *this; }
5733         LDKCVec_CVec_RouteHopZZ* operator &() { return &self; }
5734         LDKCVec_CVec_RouteHopZZ* operator ->() { return &self; }
5735         const LDKCVec_CVec_RouteHopZZ* operator &() const { return &self; }
5736         const LDKCVec_CVec_RouteHopZZ* operator ->() const { return &self; }
5737 };
5738 class CResult_TrustedCommitmentTransactionNoneZ {
5739 private:
5740         LDKCResult_TrustedCommitmentTransactionNoneZ self;
5741 public:
5742         CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
5743         CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
5744         CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
5745         operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
5746         ~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
5747         CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
5748         LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
5749         LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
5750         const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
5751         const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
5752 };
5753 class CResult_FixedPenaltyScorerDecodeErrorZ {
5754 private:
5755         LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
5756 public:
5757         CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
5758         CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
5759         CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
5760         operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
5761         ~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
5762         CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
5763         LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
5764         LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
5765         const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
5766         const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
5767 };
5768 class CResult_NoneLightningErrorZ {
5769 private:
5770         LDKCResult_NoneLightningErrorZ self;
5771 public:
5772         CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
5773         CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
5774         CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
5775         operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
5776         ~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
5777         CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
5778         LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
5779         LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
5780         const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
5781         const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
5782 };
5783 class CResult_NonePeerHandleErrorZ {
5784 private:
5785         LDKCResult_NonePeerHandleErrorZ self;
5786 public:
5787         CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
5788         CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
5789         CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
5790         operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
5791         ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
5792         CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
5793         LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
5794         LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
5795         const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
5796         const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
5797 };
5798 class CResult_COption_EventZDecodeErrorZ {
5799 private:
5800         LDKCResult_COption_EventZDecodeErrorZ self;
5801 public:
5802         CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
5803         CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
5804         CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
5805         operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
5806         ~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
5807         CResult_COption_EventZDecodeErrorZ& operator=(CResult_COption_EventZDecodeErrorZ&& o) { CResult_COption_EventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); return *this; }
5808         LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
5809         LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
5810         const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
5811         const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
5812 };
5813 class CResult_CVec_SignatureZNoneZ {
5814 private:
5815         LDKCResult_CVec_SignatureZNoneZ self;
5816 public:
5817         CResult_CVec_SignatureZNoneZ(const CResult_CVec_SignatureZNoneZ&) = delete;
5818         CResult_CVec_SignatureZNoneZ(CResult_CVec_SignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); }
5819         CResult_CVec_SignatureZNoneZ(LDKCResult_CVec_SignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); }
5820         operator LDKCResult_CVec_SignatureZNoneZ() && { LDKCResult_CVec_SignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); return res; }
5821         ~CResult_CVec_SignatureZNoneZ() { CResult_CVec_SignatureZNoneZ_free(self); }
5822         CResult_CVec_SignatureZNoneZ& operator=(CResult_CVec_SignatureZNoneZ&& o) { CResult_CVec_SignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); return *this; }
5823         LDKCResult_CVec_SignatureZNoneZ* operator &() { return &self; }
5824         LDKCResult_CVec_SignatureZNoneZ* operator ->() { return &self; }
5825         const LDKCResult_CVec_SignatureZNoneZ* operator &() const { return &self; }
5826         const LDKCResult_CVec_SignatureZNoneZ* operator ->() const { return &self; }
5827 };
5828 class COption_CVec_NetAddressZZ {
5829 private:
5830         LDKCOption_CVec_NetAddressZZ self;
5831 public:
5832         COption_CVec_NetAddressZZ(const COption_CVec_NetAddressZZ&) = delete;
5833         COption_CVec_NetAddressZZ(COption_CVec_NetAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); }
5834         COption_CVec_NetAddressZZ(LDKCOption_CVec_NetAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); }
5835         operator LDKCOption_CVec_NetAddressZZ() && { LDKCOption_CVec_NetAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); return res; }
5836         ~COption_CVec_NetAddressZZ() { COption_CVec_NetAddressZZ_free(self); }
5837         COption_CVec_NetAddressZZ& operator=(COption_CVec_NetAddressZZ&& o) { COption_CVec_NetAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); return *this; }
5838         LDKCOption_CVec_NetAddressZZ* operator &() { return &self; }
5839         LDKCOption_CVec_NetAddressZZ* operator ->() { return &self; }
5840         const LDKCOption_CVec_NetAddressZZ* operator &() const { return &self; }
5841         const LDKCOption_CVec_NetAddressZZ* operator ->() const { return &self; }
5842 };
5843 class CResult__u832APIErrorZ {
5844 private:
5845         LDKCResult__u832APIErrorZ self;
5846 public:
5847         CResult__u832APIErrorZ(const CResult__u832APIErrorZ&) = delete;
5848         CResult__u832APIErrorZ(CResult__u832APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult__u832APIErrorZ)); }
5849         CResult__u832APIErrorZ(LDKCResult__u832APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult__u832APIErrorZ)); }
5850         operator LDKCResult__u832APIErrorZ() && { LDKCResult__u832APIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult__u832APIErrorZ)); return res; }
5851         ~CResult__u832APIErrorZ() { CResult__u832APIErrorZ_free(self); }
5852         CResult__u832APIErrorZ& operator=(CResult__u832APIErrorZ&& o) { CResult__u832APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult__u832APIErrorZ)); return *this; }
5853         LDKCResult__u832APIErrorZ* operator &() { return &self; }
5854         LDKCResult__u832APIErrorZ* operator ->() { return &self; }
5855         const LDKCResult__u832APIErrorZ* operator &() const { return &self; }
5856         const LDKCResult__u832APIErrorZ* operator ->() const { return &self; }
5857 };
5858 class CResult_PaymentIdPaymentErrorZ {
5859 private:
5860         LDKCResult_PaymentIdPaymentErrorZ self;
5861 public:
5862         CResult_PaymentIdPaymentErrorZ(const CResult_PaymentIdPaymentErrorZ&) = delete;
5863         CResult_PaymentIdPaymentErrorZ(CResult_PaymentIdPaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentIdPaymentErrorZ)); }
5864         CResult_PaymentIdPaymentErrorZ(LDKCResult_PaymentIdPaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentIdPaymentErrorZ)); }
5865         operator LDKCResult_PaymentIdPaymentErrorZ() && { LDKCResult_PaymentIdPaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentIdPaymentErrorZ)); return res; }
5866         ~CResult_PaymentIdPaymentErrorZ() { CResult_PaymentIdPaymentErrorZ_free(self); }
5867         CResult_PaymentIdPaymentErrorZ& operator=(CResult_PaymentIdPaymentErrorZ&& o) { CResult_PaymentIdPaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentIdPaymentErrorZ)); return *this; }
5868         LDKCResult_PaymentIdPaymentErrorZ* operator &() { return &self; }
5869         LDKCResult_PaymentIdPaymentErrorZ* operator ->() { return &self; }
5870         const LDKCResult_PaymentIdPaymentErrorZ* operator &() const { return &self; }
5871         const LDKCResult_PaymentIdPaymentErrorZ* operator ->() const { return &self; }
5872 };
5873 class CResult_DescriptionCreationErrorZ {
5874 private:
5875         LDKCResult_DescriptionCreationErrorZ self;
5876 public:
5877         CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
5878         CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
5879         CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
5880         operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
5881         ~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
5882         CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
5883         LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
5884         LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
5885         const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
5886         const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
5887 };
5888 class CResult_COption_MonitorEventZDecodeErrorZ {
5889 private:
5890         LDKCResult_COption_MonitorEventZDecodeErrorZ self;
5891 public:
5892         CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
5893         CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
5894         CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
5895         operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
5896         ~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
5897         CResult_COption_MonitorEventZDecodeErrorZ& operator=(CResult_COption_MonitorEventZDecodeErrorZ&& o) { CResult_COption_MonitorEventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); return *this; }
5898         LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
5899         LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
5900         const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
5901         const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
5902 };
5903 class CResult_PayeePubKeyErrorZ {
5904 private:
5905         LDKCResult_PayeePubKeyErrorZ self;
5906 public:
5907         CResult_PayeePubKeyErrorZ(const CResult_PayeePubKeyErrorZ&) = delete;
5908         CResult_PayeePubKeyErrorZ(CResult_PayeePubKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); }
5909         CResult_PayeePubKeyErrorZ(LDKCResult_PayeePubKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); }
5910         operator LDKCResult_PayeePubKeyErrorZ() && { LDKCResult_PayeePubKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); return res; }
5911         ~CResult_PayeePubKeyErrorZ() { CResult_PayeePubKeyErrorZ_free(self); }
5912         CResult_PayeePubKeyErrorZ& operator=(CResult_PayeePubKeyErrorZ&& o) { CResult_PayeePubKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); return *this; }
5913         LDKCResult_PayeePubKeyErrorZ* operator &() { return &self; }
5914         LDKCResult_PayeePubKeyErrorZ* operator ->() { return &self; }
5915         const LDKCResult_PayeePubKeyErrorZ* operator &() const { return &self; }
5916         const LDKCResult_PayeePubKeyErrorZ* operator ->() const { return &self; }
5917 };
5918 class CVec_C2Tuple_PublicKeyTypeZZ {
5919 private:
5920         LDKCVec_C2Tuple_PublicKeyTypeZZ self;
5921 public:
5922         CVec_C2Tuple_PublicKeyTypeZZ(const CVec_C2Tuple_PublicKeyTypeZZ&) = delete;
5923         CVec_C2Tuple_PublicKeyTypeZZ(CVec_C2Tuple_PublicKeyTypeZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyTypeZZ)); }
5924         CVec_C2Tuple_PublicKeyTypeZZ(LDKCVec_C2Tuple_PublicKeyTypeZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); }
5925         operator LDKCVec_C2Tuple_PublicKeyTypeZZ() && { LDKCVec_C2Tuple_PublicKeyTypeZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); return res; }
5926         ~CVec_C2Tuple_PublicKeyTypeZZ() { CVec_C2Tuple_PublicKeyTypeZZ_free(self); }
5927         CVec_C2Tuple_PublicKeyTypeZZ& operator=(CVec_C2Tuple_PublicKeyTypeZZ&& o) { CVec_C2Tuple_PublicKeyTypeZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyTypeZZ)); return *this; }
5928         LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() { return &self; }
5929         LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() { return &self; }
5930         const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
5931         const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() const { return &self; }
5932 };
5933 class CResult_RoutingFeesDecodeErrorZ {
5934 private:
5935         LDKCResult_RoutingFeesDecodeErrorZ self;
5936 public:
5937         CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
5938         CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
5939         CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
5940         operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
5941         ~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
5942         CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
5943         LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
5944         LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
5945         const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
5946         const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
5947 };
5948 class CResult_QueryShortChannelIdsDecodeErrorZ {
5949 private:
5950         LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
5951 public:
5952         CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
5953         CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
5954         CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
5955         operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
5956         ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
5957         CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
5958         LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
5959         LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
5960         const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
5961         const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
5962 };
5963 class CResult_InvoiceSemanticErrorZ {
5964 private:
5965         LDKCResult_InvoiceSemanticErrorZ self;
5966 public:
5967         CResult_InvoiceSemanticErrorZ(const CResult_InvoiceSemanticErrorZ&) = delete;
5968         CResult_InvoiceSemanticErrorZ(CResult_InvoiceSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSemanticErrorZ)); }
5969         CResult_InvoiceSemanticErrorZ(LDKCResult_InvoiceSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSemanticErrorZ)); }
5970         operator LDKCResult_InvoiceSemanticErrorZ() && { LDKCResult_InvoiceSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSemanticErrorZ)); return res; }
5971         ~CResult_InvoiceSemanticErrorZ() { CResult_InvoiceSemanticErrorZ_free(self); }
5972         CResult_InvoiceSemanticErrorZ& operator=(CResult_InvoiceSemanticErrorZ&& o) { CResult_InvoiceSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSemanticErrorZ)); return *this; }
5973         LDKCResult_InvoiceSemanticErrorZ* operator &() { return &self; }
5974         LDKCResult_InvoiceSemanticErrorZ* operator ->() { return &self; }
5975         const LDKCResult_InvoiceSemanticErrorZ* operator &() const { return &self; }
5976         const LDKCResult_InvoiceSemanticErrorZ* operator ->() const { return &self; }
5977 };
5978 class CResult_UpdateAddHTLCDecodeErrorZ {
5979 private:
5980         LDKCResult_UpdateAddHTLCDecodeErrorZ self;
5981 public:
5982         CResult_UpdateAddHTLCDecodeErrorZ(const CResult_UpdateAddHTLCDecodeErrorZ&) = delete;
5983         CResult_UpdateAddHTLCDecodeErrorZ(CResult_UpdateAddHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); }
5984         CResult_UpdateAddHTLCDecodeErrorZ(LDKCResult_UpdateAddHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); }
5985         operator LDKCResult_UpdateAddHTLCDecodeErrorZ() && { LDKCResult_UpdateAddHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); return res; }
5986         ~CResult_UpdateAddHTLCDecodeErrorZ() { CResult_UpdateAddHTLCDecodeErrorZ_free(self); }
5987         CResult_UpdateAddHTLCDecodeErrorZ& operator=(CResult_UpdateAddHTLCDecodeErrorZ&& o) { CResult_UpdateAddHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); return *this; }
5988         LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() { return &self; }
5989         LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() { return &self; }
5990         const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
5991         const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
5992 };
5993 class CVec_PhantomRouteHintsZ {
5994 private:
5995         LDKCVec_PhantomRouteHintsZ self;
5996 public:
5997         CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
5998         CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
5999         CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
6000         operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
6001         ~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
6002         CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
6003         LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
6004         LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
6005         const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
6006         const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
6007 };
6008 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
6009 private:
6010         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
6011 public:
6012         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
6013         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
6014         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
6015         operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
6016         ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
6017         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
6018         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
6019         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
6020         const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
6021         const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
6022 };
6023 class CResult_NoneAPIErrorZ {
6024 private:
6025         LDKCResult_NoneAPIErrorZ self;
6026 public:
6027         CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete;
6028         CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); }
6029         CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); }
6030         operator LDKCResult_NoneAPIErrorZ() && { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; }
6031         ~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); }
6032         CResult_NoneAPIErrorZ& operator=(CResult_NoneAPIErrorZ&& o) { CResult_NoneAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); return *this; }
6033         LDKCResult_NoneAPIErrorZ* operator &() { return &self; }
6034         LDKCResult_NoneAPIErrorZ* operator ->() { return &self; }
6035         const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
6036         const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
6037 };
6038 class CVec_NetAddressZ {
6039 private:
6040         LDKCVec_NetAddressZ self;
6041 public:
6042         CVec_NetAddressZ(const CVec_NetAddressZ&) = delete;
6043         CVec_NetAddressZ(CVec_NetAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NetAddressZ)); }
6044         CVec_NetAddressZ(LDKCVec_NetAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NetAddressZ)); }
6045         operator LDKCVec_NetAddressZ() && { LDKCVec_NetAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_NetAddressZ)); return res; }
6046         ~CVec_NetAddressZ() { CVec_NetAddressZ_free(self); }
6047         CVec_NetAddressZ& operator=(CVec_NetAddressZ&& o) { CVec_NetAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NetAddressZ)); return *this; }
6048         LDKCVec_NetAddressZ* operator &() { return &self; }
6049         LDKCVec_NetAddressZ* operator ->() { return &self; }
6050         const LDKCVec_NetAddressZ* operator &() const { return &self; }
6051         const LDKCVec_NetAddressZ* operator ->() const { return &self; }
6052 };
6053 class CResult_ChannelDetailsDecodeErrorZ {
6054 private:
6055         LDKCResult_ChannelDetailsDecodeErrorZ self;
6056 public:
6057         CResult_ChannelDetailsDecodeErrorZ(const CResult_ChannelDetailsDecodeErrorZ&) = delete;
6058         CResult_ChannelDetailsDecodeErrorZ(CResult_ChannelDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); }
6059         CResult_ChannelDetailsDecodeErrorZ(LDKCResult_ChannelDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); }
6060         operator LDKCResult_ChannelDetailsDecodeErrorZ() && { LDKCResult_ChannelDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); return res; }
6061         ~CResult_ChannelDetailsDecodeErrorZ() { CResult_ChannelDetailsDecodeErrorZ_free(self); }
6062         CResult_ChannelDetailsDecodeErrorZ& operator=(CResult_ChannelDetailsDecodeErrorZ&& o) { CResult_ChannelDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); return *this; }
6063         LDKCResult_ChannelDetailsDecodeErrorZ* operator &() { return &self; }
6064         LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() { return &self; }
6065         const LDKCResult_ChannelDetailsDecodeErrorZ* operator &() const { return &self; }
6066         const LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() const { return &self; }
6067 };
6068 class CVec_C2Tuple_usizeTransactionZZ {
6069 private:
6070         LDKCVec_C2Tuple_usizeTransactionZZ self;
6071 public:
6072         CVec_C2Tuple_usizeTransactionZZ(const CVec_C2Tuple_usizeTransactionZZ&) = delete;
6073         CVec_C2Tuple_usizeTransactionZZ(CVec_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_usizeTransactionZZ)); }
6074         CVec_C2Tuple_usizeTransactionZZ(LDKCVec_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); }
6075         operator LDKCVec_C2Tuple_usizeTransactionZZ() && { LDKCVec_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); return res; }
6076         ~CVec_C2Tuple_usizeTransactionZZ() { CVec_C2Tuple_usizeTransactionZZ_free(self); }
6077         CVec_C2Tuple_usizeTransactionZZ& operator=(CVec_C2Tuple_usizeTransactionZZ&& o) { CVec_C2Tuple_usizeTransactionZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_usizeTransactionZZ)); return *this; }
6078         LDKCVec_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
6079         LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
6080         const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
6081         const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
6082 };
6083 class CVec_PublicKeyZ {
6084 private:
6085         LDKCVec_PublicKeyZ self;
6086 public:
6087         CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
6088         CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
6089         CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
6090         operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
6091         ~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
6092         CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
6093         LDKCVec_PublicKeyZ* operator &() { return &self; }
6094         LDKCVec_PublicKeyZ* operator ->() { return &self; }
6095         const LDKCVec_PublicKeyZ* operator &() const { return &self; }
6096         const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
6097 };
6098 class COption_MonitorEventZ {
6099 private:
6100         LDKCOption_MonitorEventZ self;
6101 public:
6102         COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
6103         COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
6104         COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
6105         operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
6106         ~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
6107         COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
6108         LDKCOption_MonitorEventZ* operator &() { return &self; }
6109         LDKCOption_MonitorEventZ* operator ->() { return &self; }
6110         const LDKCOption_MonitorEventZ* operator &() const { return &self; }
6111         const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
6112 };
6113 class COption_TypeZ {
6114 private:
6115         LDKCOption_TypeZ self;
6116 public:
6117         COption_TypeZ(const COption_TypeZ&) = delete;
6118         COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
6119         COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
6120         operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
6121         ~COption_TypeZ() { COption_TypeZ_free(self); }
6122         COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
6123         LDKCOption_TypeZ* operator &() { return &self; }
6124         LDKCOption_TypeZ* operator ->() { return &self; }
6125         const LDKCOption_TypeZ* operator &() const { return &self; }
6126         const LDKCOption_TypeZ* operator ->() const { return &self; }
6127 };
6128 class CResult_COption_TypeZDecodeErrorZ {
6129 private:
6130         LDKCResult_COption_TypeZDecodeErrorZ self;
6131 public:
6132         CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
6133         CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
6134         CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
6135         operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
6136         ~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
6137         CResult_COption_TypeZDecodeErrorZ& operator=(CResult_COption_TypeZDecodeErrorZ&& o) { CResult_COption_TypeZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); return *this; }
6138         LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
6139         LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
6140         const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
6141         const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
6142 };
6143 class C2Tuple_u32TxOutZ {
6144 private:
6145         LDKC2Tuple_u32TxOutZ self;
6146 public:
6147         C2Tuple_u32TxOutZ(const C2Tuple_u32TxOutZ&) = delete;
6148         C2Tuple_u32TxOutZ(C2Tuple_u32TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); }
6149         C2Tuple_u32TxOutZ(LDKC2Tuple_u32TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); }
6150         operator LDKC2Tuple_u32TxOutZ() && { LDKC2Tuple_u32TxOutZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); return res; }
6151         ~C2Tuple_u32TxOutZ() { C2Tuple_u32TxOutZ_free(self); }
6152         C2Tuple_u32TxOutZ& operator=(C2Tuple_u32TxOutZ&& o) { C2Tuple_u32TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); return *this; }
6153         LDKC2Tuple_u32TxOutZ* operator &() { return &self; }
6154         LDKC2Tuple_u32TxOutZ* operator ->() { return &self; }
6155         const LDKC2Tuple_u32TxOutZ* operator &() const { return &self; }
6156         const LDKC2Tuple_u32TxOutZ* operator ->() const { return &self; }
6157 };
6158 class CResult_UpdateFailHTLCDecodeErrorZ {
6159 private:
6160         LDKCResult_UpdateFailHTLCDecodeErrorZ self;
6161 public:
6162         CResult_UpdateFailHTLCDecodeErrorZ(const CResult_UpdateFailHTLCDecodeErrorZ&) = delete;
6163         CResult_UpdateFailHTLCDecodeErrorZ(CResult_UpdateFailHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); }
6164         CResult_UpdateFailHTLCDecodeErrorZ(LDKCResult_UpdateFailHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); }
6165         operator LDKCResult_UpdateFailHTLCDecodeErrorZ() && { LDKCResult_UpdateFailHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); return res; }
6166         ~CResult_UpdateFailHTLCDecodeErrorZ() { CResult_UpdateFailHTLCDecodeErrorZ_free(self); }
6167         CResult_UpdateFailHTLCDecodeErrorZ& operator=(CResult_UpdateFailHTLCDecodeErrorZ&& o) { CResult_UpdateFailHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); return *this; }
6168         LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() { return &self; }
6169         LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() { return &self; }
6170         const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
6171         const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
6172 };
6173 class CResult_PaymentSecretNoneZ {
6174 private:
6175         LDKCResult_PaymentSecretNoneZ self;
6176 public:
6177         CResult_PaymentSecretNoneZ(const CResult_PaymentSecretNoneZ&) = delete;
6178         CResult_PaymentSecretNoneZ(CResult_PaymentSecretNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentSecretNoneZ)); }
6179         CResult_PaymentSecretNoneZ(LDKCResult_PaymentSecretNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentSecretNoneZ)); }
6180         operator LDKCResult_PaymentSecretNoneZ() && { LDKCResult_PaymentSecretNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentSecretNoneZ)); return res; }
6181         ~CResult_PaymentSecretNoneZ() { CResult_PaymentSecretNoneZ_free(self); }
6182         CResult_PaymentSecretNoneZ& operator=(CResult_PaymentSecretNoneZ&& o) { CResult_PaymentSecretNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentSecretNoneZ)); return *this; }
6183         LDKCResult_PaymentSecretNoneZ* operator &() { return &self; }
6184         LDKCResult_PaymentSecretNoneZ* operator ->() { return &self; }
6185         const LDKCResult_PaymentSecretNoneZ* operator &() const { return &self; }
6186         const LDKCResult_PaymentSecretNoneZ* operator ->() const { return &self; }
6187 };
6188 class CResult_ChannelConfigDecodeErrorZ {
6189 private:
6190         LDKCResult_ChannelConfigDecodeErrorZ self;
6191 public:
6192         CResult_ChannelConfigDecodeErrorZ(const CResult_ChannelConfigDecodeErrorZ&) = delete;
6193         CResult_ChannelConfigDecodeErrorZ(CResult_ChannelConfigDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); }
6194         CResult_ChannelConfigDecodeErrorZ(LDKCResult_ChannelConfigDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); }
6195         operator LDKCResult_ChannelConfigDecodeErrorZ() && { LDKCResult_ChannelConfigDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); return res; }
6196         ~CResult_ChannelConfigDecodeErrorZ() { CResult_ChannelConfigDecodeErrorZ_free(self); }
6197         CResult_ChannelConfigDecodeErrorZ& operator=(CResult_ChannelConfigDecodeErrorZ&& o) { CResult_ChannelConfigDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); return *this; }
6198         LDKCResult_ChannelConfigDecodeErrorZ* operator &() { return &self; }
6199         LDKCResult_ChannelConfigDecodeErrorZ* operator ->() { return &self; }
6200         const LDKCResult_ChannelConfigDecodeErrorZ* operator &() const { return &self; }
6201         const LDKCResult_ChannelConfigDecodeErrorZ* operator ->() const { return &self; }
6202 };
6203 class CVec_PrivateRouteZ {
6204 private:
6205         LDKCVec_PrivateRouteZ self;
6206 public:
6207         CVec_PrivateRouteZ(const CVec_PrivateRouteZ&) = delete;
6208         CVec_PrivateRouteZ(CVec_PrivateRouteZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PrivateRouteZ)); }
6209         CVec_PrivateRouteZ(LDKCVec_PrivateRouteZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PrivateRouteZ)); }
6210         operator LDKCVec_PrivateRouteZ() && { LDKCVec_PrivateRouteZ res = self; memset(&self, 0, sizeof(LDKCVec_PrivateRouteZ)); return res; }
6211         ~CVec_PrivateRouteZ() { CVec_PrivateRouteZ_free(self); }
6212         CVec_PrivateRouteZ& operator=(CVec_PrivateRouteZ&& o) { CVec_PrivateRouteZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PrivateRouteZ)); return *this; }
6213         LDKCVec_PrivateRouteZ* operator &() { return &self; }
6214         LDKCVec_PrivateRouteZ* operator ->() { return &self; }
6215         const LDKCVec_PrivateRouteZ* operator &() const { return &self; }
6216         const LDKCVec_PrivateRouteZ* operator ->() const { return &self; }
6217 };
6218 class CResult_SpendableOutputDescriptorDecodeErrorZ {
6219 private:
6220         LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
6221 public:
6222         CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
6223         CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
6224         CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
6225         operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
6226         ~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
6227         CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
6228         LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
6229         LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
6230         const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
6231         const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
6232 };
6233 class CResult_RevokeAndACKDecodeErrorZ {
6234 private:
6235         LDKCResult_RevokeAndACKDecodeErrorZ self;
6236 public:
6237         CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
6238         CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
6239         CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
6240         operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
6241         ~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
6242         CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
6243         LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
6244         LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
6245         const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
6246         const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
6247 };
6248 class CResult_UnsignedChannelUpdateDecodeErrorZ {
6249 private:
6250         LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
6251 public:
6252         CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
6253         CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
6254         CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
6255         operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
6256         ~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
6257         CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
6258         LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
6259         LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
6260         const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
6261         const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
6262 };
6263 class CResult_ShutdownDecodeErrorZ {
6264 private:
6265         LDKCResult_ShutdownDecodeErrorZ self;
6266 public:
6267         CResult_ShutdownDecodeErrorZ(const CResult_ShutdownDecodeErrorZ&) = delete;
6268         CResult_ShutdownDecodeErrorZ(CResult_ShutdownDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); }
6269         CResult_ShutdownDecodeErrorZ(LDKCResult_ShutdownDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); }
6270         operator LDKCResult_ShutdownDecodeErrorZ() && { LDKCResult_ShutdownDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); return res; }
6271         ~CResult_ShutdownDecodeErrorZ() { CResult_ShutdownDecodeErrorZ_free(self); }
6272         CResult_ShutdownDecodeErrorZ& operator=(CResult_ShutdownDecodeErrorZ&& o) { CResult_ShutdownDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); return *this; }
6273         LDKCResult_ShutdownDecodeErrorZ* operator &() { return &self; }
6274         LDKCResult_ShutdownDecodeErrorZ* operator ->() { return &self; }
6275         const LDKCResult_ShutdownDecodeErrorZ* operator &() const { return &self; }
6276         const LDKCResult_ShutdownDecodeErrorZ* operator ->() const { return &self; }
6277 };
6278 class CVec_EventZ {
6279 private:
6280         LDKCVec_EventZ self;
6281 public:
6282         CVec_EventZ(const CVec_EventZ&) = delete;
6283         CVec_EventZ(CVec_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_EventZ)); }
6284         CVec_EventZ(LDKCVec_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_EventZ)); }
6285         operator LDKCVec_EventZ() && { LDKCVec_EventZ res = self; memset(&self, 0, sizeof(LDKCVec_EventZ)); return res; }
6286         ~CVec_EventZ() { CVec_EventZ_free(self); }
6287         CVec_EventZ& operator=(CVec_EventZ&& o) { CVec_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_EventZ)); return *this; }
6288         LDKCVec_EventZ* operator &() { return &self; }
6289         LDKCVec_EventZ* operator ->() { return &self; }
6290         const LDKCVec_EventZ* operator &() const { return &self; }
6291         const LDKCVec_EventZ* operator ->() const { return &self; }
6292 };
6293 class CResult_NoneSemanticErrorZ {
6294 private:
6295         LDKCResult_NoneSemanticErrorZ self;
6296 public:
6297         CResult_NoneSemanticErrorZ(const CResult_NoneSemanticErrorZ&) = delete;
6298         CResult_NoneSemanticErrorZ(CResult_NoneSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneSemanticErrorZ)); }
6299         CResult_NoneSemanticErrorZ(LDKCResult_NoneSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneSemanticErrorZ)); }
6300         operator LDKCResult_NoneSemanticErrorZ() && { LDKCResult_NoneSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneSemanticErrorZ)); return res; }
6301         ~CResult_NoneSemanticErrorZ() { CResult_NoneSemanticErrorZ_free(self); }
6302         CResult_NoneSemanticErrorZ& operator=(CResult_NoneSemanticErrorZ&& o) { CResult_NoneSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneSemanticErrorZ)); return *this; }
6303         LDKCResult_NoneSemanticErrorZ* operator &() { return &self; }
6304         LDKCResult_NoneSemanticErrorZ* operator ->() { return &self; }
6305         const LDKCResult_NoneSemanticErrorZ* operator &() const { return &self; }
6306         const LDKCResult_NoneSemanticErrorZ* operator ->() const { return &self; }
6307 };
6308 class CVec_MonitorEventZ {
6309 private:
6310         LDKCVec_MonitorEventZ self;
6311 public:
6312         CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete;
6313         CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); }
6314         CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); }
6315         operator LDKCVec_MonitorEventZ() && { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
6316         ~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
6317         CVec_MonitorEventZ& operator=(CVec_MonitorEventZ&& o) { CVec_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorEventZ)); return *this; }
6318         LDKCVec_MonitorEventZ* operator &() { return &self; }
6319         LDKCVec_MonitorEventZ* operator ->() { return &self; }
6320         const LDKCVec_MonitorEventZ* operator &() const { return &self; }
6321         const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
6322 };
6323 class CVec_PaymentPreimageZ {
6324 private:
6325         LDKCVec_PaymentPreimageZ self;
6326 public:
6327         CVec_PaymentPreimageZ(const CVec_PaymentPreimageZ&) = delete;
6328         CVec_PaymentPreimageZ(CVec_PaymentPreimageZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PaymentPreimageZ)); }
6329         CVec_PaymentPreimageZ(LDKCVec_PaymentPreimageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PaymentPreimageZ)); }
6330         operator LDKCVec_PaymentPreimageZ() && { LDKCVec_PaymentPreimageZ res = self; memset(&self, 0, sizeof(LDKCVec_PaymentPreimageZ)); return res; }
6331         ~CVec_PaymentPreimageZ() { CVec_PaymentPreimageZ_free(self); }
6332         CVec_PaymentPreimageZ& operator=(CVec_PaymentPreimageZ&& o) { CVec_PaymentPreimageZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PaymentPreimageZ)); return *this; }
6333         LDKCVec_PaymentPreimageZ* operator &() { return &self; }
6334         LDKCVec_PaymentPreimageZ* operator ->() { return &self; }
6335         const LDKCVec_PaymentPreimageZ* operator &() const { return &self; }
6336         const LDKCVec_PaymentPreimageZ* operator ->() const { return &self; }
6337 };
6338 class CVec_C2Tuple_u32ScriptZZ {
6339 private:
6340         LDKCVec_C2Tuple_u32ScriptZZ self;
6341 public:
6342         CVec_C2Tuple_u32ScriptZZ(const CVec_C2Tuple_u32ScriptZZ&) = delete;
6343         CVec_C2Tuple_u32ScriptZZ(CVec_C2Tuple_u32ScriptZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); }
6344         CVec_C2Tuple_u32ScriptZZ(LDKCVec_C2Tuple_u32ScriptZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); }
6345         operator LDKCVec_C2Tuple_u32ScriptZZ() && { LDKCVec_C2Tuple_u32ScriptZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); return res; }
6346         ~CVec_C2Tuple_u32ScriptZZ() { CVec_C2Tuple_u32ScriptZZ_free(self); }
6347         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; }
6348         LDKCVec_C2Tuple_u32ScriptZZ* operator &() { return &self; }
6349         LDKCVec_C2Tuple_u32ScriptZZ* operator ->() { return &self; }
6350         const LDKCVec_C2Tuple_u32ScriptZZ* operator &() const { return &self; }
6351         const LDKCVec_C2Tuple_u32ScriptZZ* operator ->() const { return &self; }
6352 };
6353 class CResult_NoneChannelMonitorUpdateErrZ {
6354 private:
6355         LDKCResult_NoneChannelMonitorUpdateErrZ self;
6356 public:
6357         CResult_NoneChannelMonitorUpdateErrZ(const CResult_NoneChannelMonitorUpdateErrZ&) = delete;
6358         CResult_NoneChannelMonitorUpdateErrZ(CResult_NoneChannelMonitorUpdateErrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneChannelMonitorUpdateErrZ)); }
6359         CResult_NoneChannelMonitorUpdateErrZ(LDKCResult_NoneChannelMonitorUpdateErrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); }
6360         operator LDKCResult_NoneChannelMonitorUpdateErrZ() && { LDKCResult_NoneChannelMonitorUpdateErrZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); return res; }
6361         ~CResult_NoneChannelMonitorUpdateErrZ() { CResult_NoneChannelMonitorUpdateErrZ_free(self); }
6362         CResult_NoneChannelMonitorUpdateErrZ& operator=(CResult_NoneChannelMonitorUpdateErrZ&& o) { CResult_NoneChannelMonitorUpdateErrZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneChannelMonitorUpdateErrZ)); return *this; }
6363         LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() { return &self; }
6364         LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() { return &self; }
6365         const LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() const { return &self; }
6366         const LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() const { return &self; }
6367 };
6368 class CResult_COption_ClosureReasonZDecodeErrorZ {
6369 private:
6370         LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
6371 public:
6372         CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
6373         CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
6374         CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
6375         operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
6376         ~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
6377         CResult_COption_ClosureReasonZDecodeErrorZ& operator=(CResult_COption_ClosureReasonZDecodeErrorZ&& o) { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); return *this; }
6378         LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
6379         LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
6380         const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
6381         const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
6382 };
6383 class CResult_SiPrefixNoneZ {
6384 private:
6385         LDKCResult_SiPrefixNoneZ self;
6386 public:
6387         CResult_SiPrefixNoneZ(const CResult_SiPrefixNoneZ&) = delete;
6388         CResult_SiPrefixNoneZ(CResult_SiPrefixNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixNoneZ)); }
6389         CResult_SiPrefixNoneZ(LDKCResult_SiPrefixNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixNoneZ)); }
6390         operator LDKCResult_SiPrefixNoneZ() && { LDKCResult_SiPrefixNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixNoneZ)); return res; }
6391         ~CResult_SiPrefixNoneZ() { CResult_SiPrefixNoneZ_free(self); }
6392         CResult_SiPrefixNoneZ& operator=(CResult_SiPrefixNoneZ&& o) { CResult_SiPrefixNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixNoneZ)); return *this; }
6393         LDKCResult_SiPrefixNoneZ* operator &() { return &self; }
6394         LDKCResult_SiPrefixNoneZ* operator ->() { return &self; }
6395         const LDKCResult_SiPrefixNoneZ* operator &() const { return &self; }
6396         const LDKCResult_SiPrefixNoneZ* operator ->() const { return &self; }
6397 };
6398 class CResult_PublicKeyErrorZ {
6399 private:
6400         LDKCResult_PublicKeyErrorZ self;
6401 public:
6402         CResult_PublicKeyErrorZ(const CResult_PublicKeyErrorZ&) = delete;
6403         CResult_PublicKeyErrorZ(CResult_PublicKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeyErrorZ)); }
6404         CResult_PublicKeyErrorZ(LDKCResult_PublicKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeyErrorZ)); }
6405         operator LDKCResult_PublicKeyErrorZ() && { LDKCResult_PublicKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeyErrorZ)); return res; }
6406         ~CResult_PublicKeyErrorZ() { CResult_PublicKeyErrorZ_free(self); }
6407         CResult_PublicKeyErrorZ& operator=(CResult_PublicKeyErrorZ&& o) { CResult_PublicKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeyErrorZ)); return *this; }
6408         LDKCResult_PublicKeyErrorZ* operator &() { return &self; }
6409         LDKCResult_PublicKeyErrorZ* operator ->() { return &self; }
6410         const LDKCResult_PublicKeyErrorZ* operator &() const { return &self; }
6411         const LDKCResult_PublicKeyErrorZ* operator ->() const { return &self; }
6412 };
6413 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
6414 private:
6415         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
6416 public:
6417         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
6418         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
6419         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
6420         operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
6421         ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
6422         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
6423         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
6424         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
6425         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
6426         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
6427 };
6428 class CResult_NoneNoneZ {
6429 private:
6430         LDKCResult_NoneNoneZ self;
6431 public:
6432         CResult_NoneNoneZ(const CResult_NoneNoneZ&) = delete;
6433         CResult_NoneNoneZ(CResult_NoneNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneNoneZ)); }
6434         CResult_NoneNoneZ(LDKCResult_NoneNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneNoneZ)); }
6435         operator LDKCResult_NoneNoneZ() && { LDKCResult_NoneNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneNoneZ)); return res; }
6436         ~CResult_NoneNoneZ() { CResult_NoneNoneZ_free(self); }
6437         CResult_NoneNoneZ& operator=(CResult_NoneNoneZ&& o) { CResult_NoneNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneNoneZ)); return *this; }
6438         LDKCResult_NoneNoneZ* operator &() { return &self; }
6439         LDKCResult_NoneNoneZ* operator ->() { return &self; }
6440         const LDKCResult_NoneNoneZ* operator &() const { return &self; }
6441         const LDKCResult_NoneNoneZ* operator ->() const { return &self; }
6442 };
6443 class CResult_RouteParametersDecodeErrorZ {
6444 private:
6445         LDKCResult_RouteParametersDecodeErrorZ self;
6446 public:
6447         CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
6448         CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
6449         CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
6450         operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
6451         ~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
6452         CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
6453         LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
6454         LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
6455         const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
6456         const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
6457 };
6458 class COption_ClosureReasonZ {
6459 private:
6460         LDKCOption_ClosureReasonZ self;
6461 public:
6462         COption_ClosureReasonZ(const COption_ClosureReasonZ&) = delete;
6463         COption_ClosureReasonZ(COption_ClosureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ClosureReasonZ)); }
6464         COption_ClosureReasonZ(LDKCOption_ClosureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ClosureReasonZ)); }
6465         operator LDKCOption_ClosureReasonZ() && { LDKCOption_ClosureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_ClosureReasonZ)); return res; }
6466         ~COption_ClosureReasonZ() { COption_ClosureReasonZ_free(self); }
6467         COption_ClosureReasonZ& operator=(COption_ClosureReasonZ&& o) { COption_ClosureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ClosureReasonZ)); return *this; }
6468         LDKCOption_ClosureReasonZ* operator &() { return &self; }
6469         LDKCOption_ClosureReasonZ* operator ->() { return &self; }
6470         const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
6471         const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
6472 };
6473 class CVec_APIErrorZ {
6474 private:
6475         LDKCVec_APIErrorZ self;
6476 public:
6477         CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
6478         CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
6479         CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
6480         operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
6481         ~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
6482         CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
6483         LDKCVec_APIErrorZ* operator &() { return &self; }
6484         LDKCVec_APIErrorZ* operator ->() { return &self; }
6485         const LDKCVec_APIErrorZ* operator &() const { return &self; }
6486         const LDKCVec_APIErrorZ* operator ->() const { return &self; }
6487 };
6488 class CResult_PrivateRouteCreationErrorZ {
6489 private:
6490         LDKCResult_PrivateRouteCreationErrorZ self;
6491 public:
6492         CResult_PrivateRouteCreationErrorZ(const CResult_PrivateRouteCreationErrorZ&) = delete;
6493         CResult_PrivateRouteCreationErrorZ(CResult_PrivateRouteCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); }
6494         CResult_PrivateRouteCreationErrorZ(LDKCResult_PrivateRouteCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); }
6495         operator LDKCResult_PrivateRouteCreationErrorZ() && { LDKCResult_PrivateRouteCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); return res; }
6496         ~CResult_PrivateRouteCreationErrorZ() { CResult_PrivateRouteCreationErrorZ_free(self); }
6497         CResult_PrivateRouteCreationErrorZ& operator=(CResult_PrivateRouteCreationErrorZ&& o) { CResult_PrivateRouteCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); return *this; }
6498         LDKCResult_PrivateRouteCreationErrorZ* operator &() { return &self; }
6499         LDKCResult_PrivateRouteCreationErrorZ* operator ->() { return &self; }
6500         const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
6501         const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
6502 };
6503 class CResult_boolPeerHandleErrorZ {
6504 private:
6505         LDKCResult_boolPeerHandleErrorZ self;
6506 public:
6507         CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete;
6508         CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); }
6509         CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); }
6510         operator LDKCResult_boolPeerHandleErrorZ() && { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; }
6511         ~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); }
6512         CResult_boolPeerHandleErrorZ& operator=(CResult_boolPeerHandleErrorZ&& o) { CResult_boolPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); return *this; }
6513         LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; }
6514         LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; }
6515         const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
6516         const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
6517 };
6518 class CResult_ChannelUpdateDecodeErrorZ {
6519 private:
6520         LDKCResult_ChannelUpdateDecodeErrorZ self;
6521 public:
6522         CResult_ChannelUpdateDecodeErrorZ(const CResult_ChannelUpdateDecodeErrorZ&) = delete;
6523         CResult_ChannelUpdateDecodeErrorZ(CResult_ChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); }
6524         CResult_ChannelUpdateDecodeErrorZ(LDKCResult_ChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); }
6525         operator LDKCResult_ChannelUpdateDecodeErrorZ() && { LDKCResult_ChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); return res; }
6526         ~CResult_ChannelUpdateDecodeErrorZ() { CResult_ChannelUpdateDecodeErrorZ_free(self); }
6527         CResult_ChannelUpdateDecodeErrorZ& operator=(CResult_ChannelUpdateDecodeErrorZ&& o) { CResult_ChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); return *this; }
6528         LDKCResult_ChannelUpdateDecodeErrorZ* operator &() { return &self; }
6529         LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() { return &self; }
6530         const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
6531         const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
6532 };
6533 class CVec_UpdateFulfillHTLCZ {
6534 private:
6535         LDKCVec_UpdateFulfillHTLCZ self;
6536 public:
6537         CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
6538         CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
6539         CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
6540         operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
6541         ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
6542         CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
6543         LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
6544         LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
6545         const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
6546         const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
6547 };
6548 class CResult_AnnouncementSignaturesDecodeErrorZ {
6549 private:
6550         LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
6551 public:
6552         CResult_AnnouncementSignaturesDecodeErrorZ(const CResult_AnnouncementSignaturesDecodeErrorZ&) = delete;
6553         CResult_AnnouncementSignaturesDecodeErrorZ(CResult_AnnouncementSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); }
6554         CResult_AnnouncementSignaturesDecodeErrorZ(LDKCResult_AnnouncementSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); }
6555         operator LDKCResult_AnnouncementSignaturesDecodeErrorZ() && { LDKCResult_AnnouncementSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); return res; }
6556         ~CResult_AnnouncementSignaturesDecodeErrorZ() { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); }
6557         CResult_AnnouncementSignaturesDecodeErrorZ& operator=(CResult_AnnouncementSignaturesDecodeErrorZ&& o) { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); return *this; }
6558         LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() { return &self; }
6559         LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() { return &self; }
6560         const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
6561         const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
6562 };
6563 class CResult_UpdateFulfillHTLCDecodeErrorZ {
6564 private:
6565         LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
6566 public:
6567         CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
6568         CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
6569         CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
6570         operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
6571         ~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
6572         CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
6573         LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
6574         LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
6575         const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
6576         const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
6577 };
6578 class CResult_NodeFeaturesDecodeErrorZ {
6579 private:
6580         LDKCResult_NodeFeaturesDecodeErrorZ self;
6581 public:
6582         CResult_NodeFeaturesDecodeErrorZ(const CResult_NodeFeaturesDecodeErrorZ&) = delete;
6583         CResult_NodeFeaturesDecodeErrorZ(CResult_NodeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); }
6584         CResult_NodeFeaturesDecodeErrorZ(LDKCResult_NodeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); }
6585         operator LDKCResult_NodeFeaturesDecodeErrorZ() && { LDKCResult_NodeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); return res; }
6586         ~CResult_NodeFeaturesDecodeErrorZ() { CResult_NodeFeaturesDecodeErrorZ_free(self); }
6587         CResult_NodeFeaturesDecodeErrorZ& operator=(CResult_NodeFeaturesDecodeErrorZ&& o) { CResult_NodeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); return *this; }
6588         LDKCResult_NodeFeaturesDecodeErrorZ* operator &() { return &self; }
6589         LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() { return &self; }
6590         const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
6591         const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
6592 };
6593 class CVec_u5Z {
6594 private:
6595         LDKCVec_u5Z self;
6596 public:
6597         CVec_u5Z(const CVec_u5Z&) = delete;
6598         CVec_u5Z(CVec_u5Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u5Z)); }
6599         CVec_u5Z(LDKCVec_u5Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u5Z)); }
6600         operator LDKCVec_u5Z() && { LDKCVec_u5Z res = self; memset(&self, 0, sizeof(LDKCVec_u5Z)); return res; }
6601         ~CVec_u5Z() { CVec_u5Z_free(self); }
6602         CVec_u5Z& operator=(CVec_u5Z&& o) { CVec_u5Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u5Z)); return *this; }
6603         LDKCVec_u5Z* operator &() { return &self; }
6604         LDKCVec_u5Z* operator ->() { return &self; }
6605         const LDKCVec_u5Z* operator &() const { return &self; }
6606         const LDKCVec_u5Z* operator ->() const { return &self; }
6607 };
6608 class CResult_InMemorySignerDecodeErrorZ {
6609 private:
6610         LDKCResult_InMemorySignerDecodeErrorZ self;
6611 public:
6612         CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
6613         CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
6614         CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
6615         operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
6616         ~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
6617         CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
6618         LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
6619         LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
6620         const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
6621         const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
6622 };
6623 class CResult_PaymentSecretAPIErrorZ {
6624 private:
6625         LDKCResult_PaymentSecretAPIErrorZ self;
6626 public:
6627         CResult_PaymentSecretAPIErrorZ(const CResult_PaymentSecretAPIErrorZ&) = delete;
6628         CResult_PaymentSecretAPIErrorZ(CResult_PaymentSecretAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentSecretAPIErrorZ)); }
6629         CResult_PaymentSecretAPIErrorZ(LDKCResult_PaymentSecretAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentSecretAPIErrorZ)); }
6630         operator LDKCResult_PaymentSecretAPIErrorZ() && { LDKCResult_PaymentSecretAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentSecretAPIErrorZ)); return res; }
6631         ~CResult_PaymentSecretAPIErrorZ() { CResult_PaymentSecretAPIErrorZ_free(self); }
6632         CResult_PaymentSecretAPIErrorZ& operator=(CResult_PaymentSecretAPIErrorZ&& o) { CResult_PaymentSecretAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentSecretAPIErrorZ)); return *this; }
6633         LDKCResult_PaymentSecretAPIErrorZ* operator &() { return &self; }
6634         LDKCResult_PaymentSecretAPIErrorZ* operator ->() { return &self; }
6635         const LDKCResult_PaymentSecretAPIErrorZ* operator &() const { return &self; }
6636         const LDKCResult_PaymentSecretAPIErrorZ* operator ->() const { return &self; }
6637 };
6638 class CResult_CounterpartyForwardingInfoDecodeErrorZ {
6639 private:
6640         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ self;
6641 public:
6642         CResult_CounterpartyForwardingInfoDecodeErrorZ(const CResult_CounterpartyForwardingInfoDecodeErrorZ&) = delete;
6643         CResult_CounterpartyForwardingInfoDecodeErrorZ(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); }
6644         CResult_CounterpartyForwardingInfoDecodeErrorZ(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); }
6645         operator LDKCResult_CounterpartyForwardingInfoDecodeErrorZ() && { LDKCResult_CounterpartyForwardingInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); return res; }
6646         ~CResult_CounterpartyForwardingInfoDecodeErrorZ() { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); }
6647         CResult_CounterpartyForwardingInfoDecodeErrorZ& operator=(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); return *this; }
6648         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() { return &self; }
6649         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() { return &self; }
6650         const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() const { return &self; }
6651         const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() const { return &self; }
6652 };
6653 class C2Tuple_u32ScriptZ {
6654 private:
6655         LDKC2Tuple_u32ScriptZ self;
6656 public:
6657         C2Tuple_u32ScriptZ(const C2Tuple_u32ScriptZ&) = delete;
6658         C2Tuple_u32ScriptZ(C2Tuple_u32ScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32ScriptZ)); }
6659         C2Tuple_u32ScriptZ(LDKC2Tuple_u32ScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32ScriptZ)); }
6660         operator LDKC2Tuple_u32ScriptZ() && { LDKC2Tuple_u32ScriptZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32ScriptZ)); return res; }
6661         ~C2Tuple_u32ScriptZ() { C2Tuple_u32ScriptZ_free(self); }
6662         C2Tuple_u32ScriptZ& operator=(C2Tuple_u32ScriptZ&& o) { C2Tuple_u32ScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32ScriptZ)); return *this; }
6663         LDKC2Tuple_u32ScriptZ* operator &() { return &self; }
6664         LDKC2Tuple_u32ScriptZ* operator ->() { return &self; }
6665         const LDKC2Tuple_u32ScriptZ* operator &() const { return &self; }
6666         const LDKC2Tuple_u32ScriptZ* operator ->() const { return &self; }
6667 };
6668 class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
6669 private:
6670         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
6671 public:
6672         CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
6673         CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
6674         CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
6675         operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
6676         ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
6677         CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
6678         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
6679         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
6680         const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
6681         const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
6682 };
6683 class CResult_RouteDecodeErrorZ {
6684 private:
6685         LDKCResult_RouteDecodeErrorZ self;
6686 public:
6687         CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
6688         CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
6689         CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
6690         operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
6691         ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
6692         CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
6693         LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
6694         LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
6695         const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
6696         const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
6697 };
6698 class CResult_BuiltCommitmentTransactionDecodeErrorZ {
6699 private:
6700         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ self;
6701 public:
6702         CResult_BuiltCommitmentTransactionDecodeErrorZ(const CResult_BuiltCommitmentTransactionDecodeErrorZ&) = delete;
6703         CResult_BuiltCommitmentTransactionDecodeErrorZ(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); }
6704         CResult_BuiltCommitmentTransactionDecodeErrorZ(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); }
6705         operator LDKCResult_BuiltCommitmentTransactionDecodeErrorZ() && { LDKCResult_BuiltCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); return res; }
6706         ~CResult_BuiltCommitmentTransactionDecodeErrorZ() { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); }
6707         CResult_BuiltCommitmentTransactionDecodeErrorZ& operator=(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); return *this; }
6708         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
6709         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
6710         const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
6711         const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
6712 };
6713 class COption_NoneZ {
6714 private:
6715         LDKCOption_NoneZ self;
6716 public:
6717         COption_NoneZ(const COption_NoneZ&) = delete;
6718         COption_NoneZ(COption_NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NoneZ)); }
6719         COption_NoneZ(LDKCOption_NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NoneZ)); }
6720         operator LDKCOption_NoneZ() && { LDKCOption_NoneZ res = self; memset(&self, 0, sizeof(LDKCOption_NoneZ)); return res; }
6721         ~COption_NoneZ() { COption_NoneZ_free(self); }
6722         COption_NoneZ& operator=(COption_NoneZ&& o) { COption_NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NoneZ)); return *this; }
6723         LDKCOption_NoneZ* operator &() { return &self; }
6724         LDKCOption_NoneZ* operator ->() { return &self; }
6725         const LDKCOption_NoneZ* operator &() const { return &self; }
6726         const LDKCOption_NoneZ* operator ->() const { return &self; }
6727 };
6728 class CVec_TxOutZ {
6729 private:
6730         LDKCVec_TxOutZ self;
6731 public:
6732         CVec_TxOutZ(const CVec_TxOutZ&) = delete;
6733         CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
6734         CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
6735         operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
6736         ~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
6737         CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
6738         LDKCVec_TxOutZ* operator &() { return &self; }
6739         LDKCVec_TxOutZ* operator ->() { return &self; }
6740         const LDKCVec_TxOutZ* operator &() const { return &self; }
6741         const LDKCVec_TxOutZ* operator ->() const { return &self; }
6742 };
6743 class CResult_ProbabilisticScoringParametersDecodeErrorZ {
6744 private:
6745         LDKCResult_ProbabilisticScoringParametersDecodeErrorZ self;
6746 public:
6747         CResult_ProbabilisticScoringParametersDecodeErrorZ(const CResult_ProbabilisticScoringParametersDecodeErrorZ&) = delete;
6748         CResult_ProbabilisticScoringParametersDecodeErrorZ(CResult_ProbabilisticScoringParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ProbabilisticScoringParametersDecodeErrorZ)); }
6749         CResult_ProbabilisticScoringParametersDecodeErrorZ(LDKCResult_ProbabilisticScoringParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ProbabilisticScoringParametersDecodeErrorZ)); }
6750         operator LDKCResult_ProbabilisticScoringParametersDecodeErrorZ() && { LDKCResult_ProbabilisticScoringParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ProbabilisticScoringParametersDecodeErrorZ)); return res; }
6751         ~CResult_ProbabilisticScoringParametersDecodeErrorZ() { CResult_ProbabilisticScoringParametersDecodeErrorZ_free(self); }
6752         CResult_ProbabilisticScoringParametersDecodeErrorZ& operator=(CResult_ProbabilisticScoringParametersDecodeErrorZ&& o) { CResult_ProbabilisticScoringParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ProbabilisticScoringParametersDecodeErrorZ)); return *this; }
6753         LDKCResult_ProbabilisticScoringParametersDecodeErrorZ* operator &() { return &self; }
6754         LDKCResult_ProbabilisticScoringParametersDecodeErrorZ* operator ->() { return &self; }
6755         const LDKCResult_ProbabilisticScoringParametersDecodeErrorZ* operator &() const { return &self; }
6756         const LDKCResult_ProbabilisticScoringParametersDecodeErrorZ* operator ->() const { return &self; }
6757 };
6758 class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
6759 private:
6760         LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
6761 public:
6762         CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&) = delete;
6763         CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
6764         CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
6765         operator LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return res; }
6766         ~CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); }
6767         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; }
6768         LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() { return &self; }
6769         LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
6770         const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
6771         const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
6772 };
6773 class CResult_ChannelUpdateInfoDecodeErrorZ {
6774 private:
6775         LDKCResult_ChannelUpdateInfoDecodeErrorZ self;
6776 public:
6777         CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
6778         CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
6779         CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
6780         operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
6781         ~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
6782         CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
6783         LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
6784         LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
6785         const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
6786         const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
6787 };
6788 class CVec_UpdateFailHTLCZ {
6789 private:
6790         LDKCVec_UpdateFailHTLCZ self;
6791 public:
6792         CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
6793         CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
6794         CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
6795         operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
6796         ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
6797         CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
6798         LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
6799         LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
6800         const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
6801         const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
6802 };
6803 class CResult_FundingLockedDecodeErrorZ {
6804 private:
6805         LDKCResult_FundingLockedDecodeErrorZ self;
6806 public:
6807         CResult_FundingLockedDecodeErrorZ(const CResult_FundingLockedDecodeErrorZ&) = delete;
6808         CResult_FundingLockedDecodeErrorZ(CResult_FundingLockedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingLockedDecodeErrorZ)); }
6809         CResult_FundingLockedDecodeErrorZ(LDKCResult_FundingLockedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingLockedDecodeErrorZ)); }
6810         operator LDKCResult_FundingLockedDecodeErrorZ() && { LDKCResult_FundingLockedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingLockedDecodeErrorZ)); return res; }
6811         ~CResult_FundingLockedDecodeErrorZ() { CResult_FundingLockedDecodeErrorZ_free(self); }
6812         CResult_FundingLockedDecodeErrorZ& operator=(CResult_FundingLockedDecodeErrorZ&& o) { CResult_FundingLockedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingLockedDecodeErrorZ)); return *this; }
6813         LDKCResult_FundingLockedDecodeErrorZ* operator &() { return &self; }
6814         LDKCResult_FundingLockedDecodeErrorZ* operator ->() { return &self; }
6815         const LDKCResult_FundingLockedDecodeErrorZ* operator &() const { return &self; }
6816         const LDKCResult_FundingLockedDecodeErrorZ* operator ->() const { return &self; }
6817 };
6818
6819 inline LDK::CResult_NoneErrorZ ChannelManagerPersister::persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager) {
6820         LDK::CResult_NoneErrorZ ret = (self.persist_manager)(self.this_arg, channel_manager);
6821         return ret;
6822 }
6823 inline void BroadcasterInterface::broadcast_transaction(struct LDKTransaction tx) {
6824         (self.broadcast_transaction)(self.this_arg, tx);
6825 }
6826 inline uint32_t FeeEstimator::get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target) {
6827         uint32_t ret = (self.get_est_sat_per_1000_weight)(self.this_arg, confirmation_target);
6828         return ret;
6829 }
6830 inline LDK::CResult_TxOutAccessErrorZ Access::get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id) {
6831         LDK::CResult_TxOutAccessErrorZ ret = (self.get_utxo)(self.this_arg, genesis_hash, short_channel_id);
6832         return ret;
6833 }
6834 inline void Listen::block_connected(struct LDKu8slice block, uint32_t height) {
6835         (self.block_connected)(self.this_arg, block, height);
6836 }
6837 inline void Listen::block_disconnected(const uint8_t (*header)[80], uint32_t height) {
6838         (self.block_disconnected)(self.this_arg, header, height);
6839 }
6840 inline void Confirm::transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
6841         (self.transactions_confirmed)(self.this_arg, header, txdata, height);
6842 }
6843 inline void Confirm::transaction_unconfirmed(const uint8_t (*txid)[32]) {
6844         (self.transaction_unconfirmed)(self.this_arg, txid);
6845 }
6846 inline void Confirm::best_block_updated(const uint8_t (*header)[80], uint32_t height) {
6847         (self.best_block_updated)(self.this_arg, header, height);
6848 }
6849 inline LDK::CVec_TxidZ Confirm::get_relevant_txids() {
6850         LDK::CVec_TxidZ ret = (self.get_relevant_txids)(self.this_arg);
6851         return ret;
6852 }
6853 inline LDK::CResult_NoneChannelMonitorUpdateErrZ Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
6854         LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.watch_channel)(self.this_arg, funding_txo, monitor);
6855         return ret;
6856 }
6857 inline LDK::CResult_NoneChannelMonitorUpdateErrZ Watch::update_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update) {
6858         LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.update_channel)(self.this_arg, funding_txo, update);
6859         return ret;
6860 }
6861 inline LDK::CVec_MonitorEventZ Watch::release_pending_monitor_events() {
6862         LDK::CVec_MonitorEventZ ret = (self.release_pending_monitor_events)(self.this_arg);
6863         return ret;
6864 }
6865 inline void Filter::register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey) {
6866         (self.register_tx)(self.this_arg, txid, script_pubkey);
6867 }
6868 inline LDK::COption_C2Tuple_usizeTransactionZZ Filter::register_output(struct LDKWatchedOutput output) {
6869         LDK::COption_C2Tuple_usizeTransactionZZ ret = (self.register_output)(self.this_arg, output);
6870         return ret;
6871 }
6872 inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
6873         LDK::CVec_MessageSendEventZ ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
6874         return ret;
6875 }
6876 inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
6877         (self.process_pending_events)(self.this_arg, handler);
6878 }
6879 inline void EventHandler::handle_event(const struct LDKEvent *NONNULL_PTR event) {
6880         (self.handle_event)(self.this_arg, event);
6881 }
6882 inline uint64_t Score::channel_penalty_msat(uint64_t short_channel_id, uint64_t send_amt_msat, uint64_t capacity_msat, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target) {
6883         uint64_t ret = (self.channel_penalty_msat)(self.this_arg, short_channel_id, send_amt_msat, capacity_msat, source, target);
6884         return ret;
6885 }
6886 inline void Score::payment_path_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
6887         (self.payment_path_failed)(self.this_arg, path, short_channel_id);
6888 }
6889 inline void Score::payment_path_successful(struct LDKCVec_RouteHopZ path) {
6890         (self.payment_path_successful)(self.this_arg, path);
6891 }
6892 inline LDK::Score LockableScore::lock() {
6893         LDK::Score ret = (self.lock)(self.this_arg);
6894         return ret;
6895 }
6896 inline LDKPublicKey BaseSign::get_per_commitment_point(uint64_t idx) {
6897         LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
6898         return ret;
6899 }
6900 inline LDKThirtyTwoBytes BaseSign::release_commitment_secret(uint64_t idx) {
6901         LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
6902         return ret;
6903 }
6904 inline LDK::CResult_NoneNoneZ BaseSign::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages) {
6905         LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, preimages);
6906         return ret;
6907 }
6908 inline LDKThirtyTwoBytes BaseSign::channel_keys_id() {
6909         LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
6910         return ret;
6911 }
6912 inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages) {
6913         LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, preimages);
6914         return ret;
6915 }
6916 inline LDK::CResult_NoneNoneZ BaseSign::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
6917         LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
6918         return ret;
6919 }
6920 inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign::sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
6921         LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = (self.sign_holder_commitment_and_htlcs)(self.this_arg, commitment_tx);
6922         return ret;
6923 }
6924 inline LDK::CResult_SignatureNoneZ BaseSign::sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]) {
6925         LDK::CResult_SignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
6926         return ret;
6927 }
6928 inline LDK::CResult_SignatureNoneZ BaseSign::sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
6929         LDK::CResult_SignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
6930         return ret;
6931 }
6932 inline LDK::CResult_SignatureNoneZ BaseSign::sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
6933         LDK::CResult_SignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
6934         return ret;
6935 }
6936 inline LDK::CResult_SignatureNoneZ BaseSign::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
6937         LDK::CResult_SignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
6938         return ret;
6939 }
6940 inline LDK::CResult_C2Tuple_SignatureSignatureZNoneZ BaseSign::sign_channel_announcement(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
6941         LDK::CResult_C2Tuple_SignatureSignatureZNoneZ ret = (self.sign_channel_announcement)(self.this_arg, msg);
6942         return ret;
6943 }
6944 inline void BaseSign::ready_channel(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
6945         (self.ready_channel)(self.this_arg, channel_parameters);
6946 }
6947 inline LDK::CResult_SecretKeyNoneZ KeysInterface::get_node_secret(enum LDKRecipient recipient) {
6948         LDK::CResult_SecretKeyNoneZ ret = (self.get_node_secret)(self.this_arg, recipient);
6949         return ret;
6950 }
6951 inline LDK::CVec_u8Z KeysInterface::get_destination_script() {
6952         LDK::CVec_u8Z ret = (self.get_destination_script)(self.this_arg);
6953         return ret;
6954 }
6955 inline LDK::ShutdownScript KeysInterface::get_shutdown_scriptpubkey() {
6956         LDK::ShutdownScript ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
6957         return ret;
6958 }
6959 inline LDK::Sign KeysInterface::get_channel_signer(bool inbound, uint64_t channel_value_satoshis) {
6960         LDK::Sign ret = (self.get_channel_signer)(self.this_arg, inbound, channel_value_satoshis);
6961         return ret;
6962 }
6963 inline LDKThirtyTwoBytes KeysInterface::get_secure_random_bytes() {
6964         LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
6965         return ret;
6966 }
6967 inline LDK::CResult_SignDecodeErrorZ KeysInterface::read_chan_signer(struct LDKu8slice reader) {
6968         LDK::CResult_SignDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
6969         return ret;
6970 }
6971 inline LDK::CResult_RecoverableSignatureNoneZ KeysInterface::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient) {
6972         LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, receipient);
6973         return ret;
6974 }
6975 inline LDKThirtyTwoBytes KeysInterface::get_inbound_payment_key_material() {
6976         LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
6977         return ret;
6978 }
6979 inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
6980         LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
6981         return ret;
6982 }
6983 inline uint16_t Type::type_id() {
6984         uint16_t ret = (self.type_id)(self.this_arg);
6985         return ret;
6986 }
6987 inline LDK::Str Type::debug_str() {
6988         LDK::Str ret = (self.debug_str)(self.this_arg);
6989         return ret;
6990 }
6991 inline LDKPublicKey Payer::node_id() {
6992         LDKPublicKey ret = (self.node_id)(self.this_arg);
6993         return ret;
6994 }
6995 inline LDK::CVec_ChannelDetailsZ Payer::first_hops() {
6996         LDK::CVec_ChannelDetailsZ ret = (self.first_hops)(self.this_arg);
6997         return ret;
6998 }
6999 inline LDK::CResult_PaymentIdPaymentSendFailureZ Payer::send_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret) {
7000         LDK::CResult_PaymentIdPaymentSendFailureZ ret = (self.send_payment)(self.this_arg, route, payment_hash, payment_secret);
7001         return ret;
7002 }
7003 inline LDK::CResult_PaymentIdPaymentSendFailureZ Payer::send_spontaneous_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage) {
7004         LDK::CResult_PaymentIdPaymentSendFailureZ ret = (self.send_spontaneous_payment)(self.this_arg, route, payment_preimage);
7005         return ret;
7006 }
7007 inline LDK::CResult_NonePaymentSendFailureZ Payer::retry_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id) {
7008         LDK::CResult_NonePaymentSendFailureZ ret = (self.retry_payment)(self.this_arg, route, payment_id);
7009         return ret;
7010 }
7011 inline void Payer::abandon_payment(struct LDKThirtyTwoBytes payment_id) {
7012         (self.abandon_payment)(self.this_arg, payment_id);
7013 }
7014 inline LDK::CResult_RouteLightningErrorZ Router::find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKScore *NONNULL_PTR scorer) {
7015         LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, payment_hash, first_hops, scorer);
7016         return ret;
7017 }
7018 inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
7019         LDK::CResult_NoneLightningErrorZ ret = (self.handle_custom_message)(self.this_arg, msg, sender_node_id);
7020         return ret;
7021 }
7022 inline LDK::CVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler::get_and_clear_pending_msg() {
7023         LDK::CVec_C2Tuple_PublicKeyTypeZZ ret = (self.get_and_clear_pending_msg)(self.this_arg);
7024         return ret;
7025 }
7026 inline uintptr_t SocketDescriptor::send_data(struct LDKu8slice data, bool resume_read) {
7027         uintptr_t ret = (self.send_data)(self.this_arg, data, resume_read);
7028         return ret;
7029 }
7030 inline void SocketDescriptor::disconnect_socket() {
7031         (self.disconnect_socket)(self.this_arg);
7032 }
7033 inline bool SocketDescriptor::eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg) {
7034         bool ret = (self.eq)(self.this_arg, other_arg);
7035         return ret;
7036 }
7037 inline uint64_t SocketDescriptor::hash() {
7038         uint64_t ret = (self.hash)(self.this_arg);
7039         return ret;
7040 }
7041 inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKOpenChannel *NONNULL_PTR msg) {
7042         (self.handle_open_channel)(self.this_arg, their_node_id, their_features, msg);
7043 }
7044 inline void ChannelMessageHandler::handle_accept_channel(struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKAcceptChannel *NONNULL_PTR msg) {
7045         (self.handle_accept_channel)(self.this_arg, their_node_id, their_features, msg);
7046 }
7047 inline void ChannelMessageHandler::handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg) {
7048         (self.handle_funding_created)(self.this_arg, their_node_id, msg);
7049 }
7050 inline void ChannelMessageHandler::handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg) {
7051         (self.handle_funding_signed)(self.this_arg, their_node_id, msg);
7052 }
7053 inline void ChannelMessageHandler::handle_funding_locked(struct LDKPublicKey their_node_id, const struct LDKFundingLocked *NONNULL_PTR msg) {
7054         (self.handle_funding_locked)(self.this_arg, their_node_id, msg);
7055 }
7056 inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKInitFeatures *NONNULL_PTR their_features, const struct LDKShutdown *NONNULL_PTR msg) {
7057         (self.handle_shutdown)(self.this_arg, their_node_id, their_features, msg);
7058 }
7059 inline void ChannelMessageHandler::handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg) {
7060         (self.handle_closing_signed)(self.this_arg, their_node_id, msg);
7061 }
7062 inline void ChannelMessageHandler::handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg) {
7063         (self.handle_update_add_htlc)(self.this_arg, their_node_id, msg);
7064 }
7065 inline void ChannelMessageHandler::handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg) {
7066         (self.handle_update_fulfill_htlc)(self.this_arg, their_node_id, msg);
7067 }
7068 inline void ChannelMessageHandler::handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg) {
7069         (self.handle_update_fail_htlc)(self.this_arg, their_node_id, msg);
7070 }
7071 inline void ChannelMessageHandler::handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg) {
7072         (self.handle_update_fail_malformed_htlc)(self.this_arg, their_node_id, msg);
7073 }
7074 inline void ChannelMessageHandler::handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg) {
7075         (self.handle_commitment_signed)(self.this_arg, their_node_id, msg);
7076 }
7077 inline void ChannelMessageHandler::handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg) {
7078         (self.handle_revoke_and_ack)(self.this_arg, their_node_id, msg);
7079 }
7080 inline void ChannelMessageHandler::handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg) {
7081         (self.handle_update_fee)(self.this_arg, their_node_id, msg);
7082 }
7083 inline void ChannelMessageHandler::handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg) {
7084         (self.handle_announcement_signatures)(self.this_arg, their_node_id, msg);
7085 }
7086 inline void ChannelMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id, bool no_connection_possible) {
7087         (self.peer_disconnected)(self.this_arg, their_node_id, no_connection_possible);
7088 }
7089 inline void ChannelMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg) {
7090         (self.peer_connected)(self.this_arg, their_node_id, msg);
7091 }
7092 inline void ChannelMessageHandler::handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg) {
7093         (self.handle_channel_reestablish)(self.this_arg, their_node_id, msg);
7094 }
7095 inline void ChannelMessageHandler::handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg) {
7096         (self.handle_channel_update)(self.this_arg, their_node_id, msg);
7097 }
7098 inline void ChannelMessageHandler::handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg) {
7099         (self.handle_error)(self.this_arg, their_node_id, msg);
7100 }
7101 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg) {
7102         LDK::CResult_boolLightningErrorZ ret = (self.handle_node_announcement)(self.this_arg, msg);
7103         return ret;
7104 }
7105 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg) {
7106         LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_announcement)(self.this_arg, msg);
7107         return ret;
7108 }
7109 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg) {
7110         LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_update)(self.this_arg, msg);
7111         return ret;
7112 }
7113 inline LDK::CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler::get_next_channel_announcements(uint64_t starting_point, uint8_t batch_amount) {
7114         LDK::CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = (self.get_next_channel_announcements)(self.this_arg, starting_point, batch_amount);
7115         return ret;
7116 }
7117 inline LDK::CVec_NodeAnnouncementZ RoutingMessageHandler::get_next_node_announcements(struct LDKPublicKey starting_point, uint8_t batch_amount) {
7118         LDK::CVec_NodeAnnouncementZ ret = (self.get_next_node_announcements)(self.this_arg, starting_point, batch_amount);
7119         return ret;
7120 }
7121 inline void RoutingMessageHandler::sync_routing_table(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init) {
7122         (self.sync_routing_table)(self.this_arg, their_node_id, init);
7123 }
7124 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg) {
7125         LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_channel_range)(self.this_arg, their_node_id, msg);
7126         return ret;
7127 }
7128 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg) {
7129         LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_short_channel_ids_end)(self.this_arg, their_node_id, msg);
7130         return ret;
7131 }
7132 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg) {
7133         LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_channel_range)(self.this_arg, their_node_id, msg);
7134         return ret;
7135 }
7136 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg) {
7137         LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_short_channel_ids)(self.this_arg, their_node_id, msg);
7138         return ret;
7139 }
7140 inline void Logger::log(const struct LDKRecord *NONNULL_PTR record) {
7141         (self.log)(self.this_arg, record);
7142 }
7143 inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
7144         LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.persist_new_channel)(self.this_arg, channel_id, data, update_id);
7145         return ret;
7146 }
7147 inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::update_persisted_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
7148         LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.update_persisted_channel)(self.this_arg, channel_id, update, data, update_id);
7149         return ret;
7150 }
7151 }